From f9ee0c8c17738f932717e013ab89023b7f4ca7fd Mon Sep 17 00:00:00 2001 From: Robin Tang Date: Fri, 6 Dec 2024 15:29:32 -0500 Subject: [PATCH] Checking in ANTLR files (#577) --- .github/workflows/go-checks.yaml | 10 - .gitignore | 1 + Makefile | 5 - lib/antlr/generated/mysql_lexer.go | 8311 + lib/antlr/generated/mysql_parser.go | 130975 +++++++++++++++ .../generated/mysqlparser_base_listener.go | 3863 + lib/antlr/generated/mysqlparser_listener.go | 3717 + 7 files changed, 146867 insertions(+), 15 deletions(-) create mode 100644 lib/antlr/generated/mysql_lexer.go create mode 100644 lib/antlr/generated/mysql_parser.go create mode 100644 lib/antlr/generated/mysqlparser_base_listener.go create mode 100644 lib/antlr/generated/mysqlparser_listener.go diff --git a/.github/workflows/go-checks.yaml b/.github/workflows/go-checks.yaml index 6f3ece4b..ae123511 100644 --- a/.github/workflows/go-checks.yaml +++ b/.github/workflows/go-checks.yaml @@ -17,16 +17,6 @@ jobs: - name: Download dependencies run: go mod download - - name: Install antlr - run: | - curl -O https://www.antlr.org/download/antlr-4.13.2-complete.jar - echo "ANTLR_JAR=$(pwd)/antlr-4.13.2-complete.jar" >> $GITHUB_ENV - - - name: Generate antlr files - run: make gh_antlr - env: - ANTLR: java -jar ${{ env.ANTLR_JAR }} - - name: Run vet run: make vet diff --git a/.gitignore b/.gitignore index a30197e1..926025a9 100644 --- a/.gitignore +++ b/.gitignore @@ -1,6 +1,7 @@ ## Generated ANTLR lib/antlr/generated/* !lib/antlr/generated/*.g4 +!lib/antlr/generated/*.go ### Terraform ### # Local .terraform directories diff --git a/Makefile b/Makefile index 39137d08..57454a95 100644 --- a/Makefile +++ b/Makefile @@ -5,11 +5,6 @@ GENERATED_ANTLR_DIR = github.com/artie-labs/reader/lib/antlr/generated antlr: cd $(ANTLR_DIR); antlr -package generated -Dlanguage=Go *.g4 -.PHONY: gh_antlr -gh_antlr: - # https://github.com/antlr/antlr4/blob/master/doc/tool-options.md - cd $(ANTLR_DIR); $(ANTLR) -package generated -Dlanguage=Go *.g4 - .PHONY: vet vet: go vet $(go list ./... | grep -v $(GENERATED_ANTLR_DIR)) diff --git a/lib/antlr/generated/mysql_lexer.go b/lib/antlr/generated/mysql_lexer.go new file mode 100644 index 00000000..db342f2e --- /dev/null +++ b/lib/antlr/generated/mysql_lexer.go @@ -0,0 +1,8311 @@ +// Code generated from MySqlLexer.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package generated + +import ( + "fmt" + "github.com/antlr4-go/antlr/v4" + "sync" + "unicode" +) + +// Suppress unused import error +var _ = fmt.Printf +var _ = sync.Once{} +var _ = unicode.IsLetter + +type MySqlLexer struct { + *antlr.BaseLexer + channelNames []string + modeNames []string + // TODO: EOF string +} + +var MySqlLexerLexerStaticData struct { + once sync.Once + serializedATN []int32 + ChannelNames []string + ModeNames []string + LiteralNames []string + SymbolicNames []string + RuleNames []string + PredictionContextCache *antlr.PredictionContextCache + atn *antlr.ATN + decisionToDFA []*antlr.DFA +} + +func mysqllexerLexerInit() { + staticData := &MySqlLexerLexerStaticData + staticData.ChannelNames = []string{ + "DEFAULT_TOKEN_CHANNEL", "HIDDEN", "MYSQLCOMMENT", "ERRORCHANNEL", + } + staticData.ModeNames = []string{ + "DEFAULT_MODE", + } + staticData.LiteralNames = []string{ + "", "", "", "", "", "'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'", "'VECTOR'", "'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'", "", "'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'", "'DISTANCE'", "'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'", "'STRING_TO_VECTOR'", "'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'", + "'VECTOR_DIM'", "'VECTOR_TO_STRING'", "'VERSION'", "'WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS'", + "'WEEKDAY'", "'WEEKOFYEAR'", "'WEIGHT_STRING'", "'WITHIN'", "'YEARWEEK'", + "'Y'", "'X'", "':='", "'+='", "'-='", "'*='", "'/='", "'%='", "'&='", + "'^='", "'|='", "'*'", "'/'", "'%'", "'+'", "'-'", "'DIV'", "'MOD'", + "'='", "'>'", "'<'", "'!'", "'~'", "'|'", "'&'", "'^'", "'.'", "'('", + "')'", "','", "';'", "'@'", "'0'", "'1'", "'2'", "'''", "'\"'", "'`'", + "':'", + } + staticData.SymbolicNames = []string{ + "", "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", + "VECTOR", "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", "DISTANCE", "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", "STRING_TO_VECTOR", "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", + "VECTOR_DIM", "VECTOR_TO_STRING", "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", + } + staticData.RuleNames = []string{ + "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", "VECTOR", "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", "DISTANCE", "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", "STRING_TO_VECTOR", "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", + "VECTOR_DIM", "VECTOR_TO_STRING", "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", + } + staticData.PredictionContextCache = antlr.NewPredictionContextCache() + staticData.serializedATN = []int32{ + 4, 0, 1166, 13774, 6, -1, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, + 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, + 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, + 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, + 20, 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, + 7, 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, + 30, 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, + 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, + 41, 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, + 7, 46, 2, 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, + 51, 2, 52, 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, + 2, 57, 7, 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, + 62, 7, 62, 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, + 7, 67, 2, 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, + 72, 2, 73, 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, + 2, 78, 7, 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, + 83, 7, 83, 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, + 7, 88, 2, 89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 2, 93, 7, + 93, 2, 94, 7, 94, 2, 95, 7, 95, 2, 96, 7, 96, 2, 97, 7, 97, 2, 98, 7, 98, + 2, 99, 7, 99, 2, 100, 7, 100, 2, 101, 7, 101, 2, 102, 7, 102, 2, 103, 7, + 103, 2, 104, 7, 104, 2, 105, 7, 105, 2, 106, 7, 106, 2, 107, 7, 107, 2, + 108, 7, 108, 2, 109, 7, 109, 2, 110, 7, 110, 2, 111, 7, 111, 2, 112, 7, + 112, 2, 113, 7, 113, 2, 114, 7, 114, 2, 115, 7, 115, 2, 116, 7, 116, 2, + 117, 7, 117, 2, 118, 7, 118, 2, 119, 7, 119, 2, 120, 7, 120, 2, 121, 7, + 121, 2, 122, 7, 122, 2, 123, 7, 123, 2, 124, 7, 124, 2, 125, 7, 125, 2, + 126, 7, 126, 2, 127, 7, 127, 2, 128, 7, 128, 2, 129, 7, 129, 2, 130, 7, + 130, 2, 131, 7, 131, 2, 132, 7, 132, 2, 133, 7, 133, 2, 134, 7, 134, 2, + 135, 7, 135, 2, 136, 7, 136, 2, 137, 7, 137, 2, 138, 7, 138, 2, 139, 7, + 139, 2, 140, 7, 140, 2, 141, 7, 141, 2, 142, 7, 142, 2, 143, 7, 143, 2, + 144, 7, 144, 2, 145, 7, 145, 2, 146, 7, 146, 2, 147, 7, 147, 2, 148, 7, + 148, 2, 149, 7, 149, 2, 150, 7, 150, 2, 151, 7, 151, 2, 152, 7, 152, 2, + 153, 7, 153, 2, 154, 7, 154, 2, 155, 7, 155, 2, 156, 7, 156, 2, 157, 7, + 157, 2, 158, 7, 158, 2, 159, 7, 159, 2, 160, 7, 160, 2, 161, 7, 161, 2, + 162, 7, 162, 2, 163, 7, 163, 2, 164, 7, 164, 2, 165, 7, 165, 2, 166, 7, + 166, 2, 167, 7, 167, 2, 168, 7, 168, 2, 169, 7, 169, 2, 170, 7, 170, 2, + 171, 7, 171, 2, 172, 7, 172, 2, 173, 7, 173, 2, 174, 7, 174, 2, 175, 7, + 175, 2, 176, 7, 176, 2, 177, 7, 177, 2, 178, 7, 178, 2, 179, 7, 179, 2, + 180, 7, 180, 2, 181, 7, 181, 2, 182, 7, 182, 2, 183, 7, 183, 2, 184, 7, + 184, 2, 185, 7, 185, 2, 186, 7, 186, 2, 187, 7, 187, 2, 188, 7, 188, 2, + 189, 7, 189, 2, 190, 7, 190, 2, 191, 7, 191, 2, 192, 7, 192, 2, 193, 7, + 193, 2, 194, 7, 194, 2, 195, 7, 195, 2, 196, 7, 196, 2, 197, 7, 197, 2, + 198, 7, 198, 2, 199, 7, 199, 2, 200, 7, 200, 2, 201, 7, 201, 2, 202, 7, + 202, 2, 203, 7, 203, 2, 204, 7, 204, 2, 205, 7, 205, 2, 206, 7, 206, 2, + 207, 7, 207, 2, 208, 7, 208, 2, 209, 7, 209, 2, 210, 7, 210, 2, 211, 7, + 211, 2, 212, 7, 212, 2, 213, 7, 213, 2, 214, 7, 214, 2, 215, 7, 215, 2, + 216, 7, 216, 2, 217, 7, 217, 2, 218, 7, 218, 2, 219, 7, 219, 2, 220, 7, + 220, 2, 221, 7, 221, 2, 222, 7, 222, 2, 223, 7, 223, 2, 224, 7, 224, 2, + 225, 7, 225, 2, 226, 7, 226, 2, 227, 7, 227, 2, 228, 7, 228, 2, 229, 7, + 229, 2, 230, 7, 230, 2, 231, 7, 231, 2, 232, 7, 232, 2, 233, 7, 233, 2, + 234, 7, 234, 2, 235, 7, 235, 2, 236, 7, 236, 2, 237, 7, 237, 2, 238, 7, + 238, 2, 239, 7, 239, 2, 240, 7, 240, 2, 241, 7, 241, 2, 242, 7, 242, 2, + 243, 7, 243, 2, 244, 7, 244, 2, 245, 7, 245, 2, 246, 7, 246, 2, 247, 7, + 247, 2, 248, 7, 248, 2, 249, 7, 249, 2, 250, 7, 250, 2, 251, 7, 251, 2, + 252, 7, 252, 2, 253, 7, 253, 2, 254, 7, 254, 2, 255, 7, 255, 2, 256, 7, + 256, 2, 257, 7, 257, 2, 258, 7, 258, 2, 259, 7, 259, 2, 260, 7, 260, 2, + 261, 7, 261, 2, 262, 7, 262, 2, 263, 7, 263, 2, 264, 7, 264, 2, 265, 7, + 265, 2, 266, 7, 266, 2, 267, 7, 267, 2, 268, 7, 268, 2, 269, 7, 269, 2, + 270, 7, 270, 2, 271, 7, 271, 2, 272, 7, 272, 2, 273, 7, 273, 2, 274, 7, + 274, 2, 275, 7, 275, 2, 276, 7, 276, 2, 277, 7, 277, 2, 278, 7, 278, 2, + 279, 7, 279, 2, 280, 7, 280, 2, 281, 7, 281, 2, 282, 7, 282, 2, 283, 7, + 283, 2, 284, 7, 284, 2, 285, 7, 285, 2, 286, 7, 286, 2, 287, 7, 287, 2, + 288, 7, 288, 2, 289, 7, 289, 2, 290, 7, 290, 2, 291, 7, 291, 2, 292, 7, + 292, 2, 293, 7, 293, 2, 294, 7, 294, 2, 295, 7, 295, 2, 296, 7, 296, 2, + 297, 7, 297, 2, 298, 7, 298, 2, 299, 7, 299, 2, 300, 7, 300, 2, 301, 7, + 301, 2, 302, 7, 302, 2, 303, 7, 303, 2, 304, 7, 304, 2, 305, 7, 305, 2, + 306, 7, 306, 2, 307, 7, 307, 2, 308, 7, 308, 2, 309, 7, 309, 2, 310, 7, + 310, 2, 311, 7, 311, 2, 312, 7, 312, 2, 313, 7, 313, 2, 314, 7, 314, 2, + 315, 7, 315, 2, 316, 7, 316, 2, 317, 7, 317, 2, 318, 7, 318, 2, 319, 7, + 319, 2, 320, 7, 320, 2, 321, 7, 321, 2, 322, 7, 322, 2, 323, 7, 323, 2, + 324, 7, 324, 2, 325, 7, 325, 2, 326, 7, 326, 2, 327, 7, 327, 2, 328, 7, + 328, 2, 329, 7, 329, 2, 330, 7, 330, 2, 331, 7, 331, 2, 332, 7, 332, 2, + 333, 7, 333, 2, 334, 7, 334, 2, 335, 7, 335, 2, 336, 7, 336, 2, 337, 7, + 337, 2, 338, 7, 338, 2, 339, 7, 339, 2, 340, 7, 340, 2, 341, 7, 341, 2, + 342, 7, 342, 2, 343, 7, 343, 2, 344, 7, 344, 2, 345, 7, 345, 2, 346, 7, + 346, 2, 347, 7, 347, 2, 348, 7, 348, 2, 349, 7, 349, 2, 350, 7, 350, 2, + 351, 7, 351, 2, 352, 7, 352, 2, 353, 7, 353, 2, 354, 7, 354, 2, 355, 7, + 355, 2, 356, 7, 356, 2, 357, 7, 357, 2, 358, 7, 358, 2, 359, 7, 359, 2, + 360, 7, 360, 2, 361, 7, 361, 2, 362, 7, 362, 2, 363, 7, 363, 2, 364, 7, + 364, 2, 365, 7, 365, 2, 366, 7, 366, 2, 367, 7, 367, 2, 368, 7, 368, 2, + 369, 7, 369, 2, 370, 7, 370, 2, 371, 7, 371, 2, 372, 7, 372, 2, 373, 7, + 373, 2, 374, 7, 374, 2, 375, 7, 375, 2, 376, 7, 376, 2, 377, 7, 377, 2, + 378, 7, 378, 2, 379, 7, 379, 2, 380, 7, 380, 2, 381, 7, 381, 2, 382, 7, + 382, 2, 383, 7, 383, 2, 384, 7, 384, 2, 385, 7, 385, 2, 386, 7, 386, 2, + 387, 7, 387, 2, 388, 7, 388, 2, 389, 7, 389, 2, 390, 7, 390, 2, 391, 7, + 391, 2, 392, 7, 392, 2, 393, 7, 393, 2, 394, 7, 394, 2, 395, 7, 395, 2, + 396, 7, 396, 2, 397, 7, 397, 2, 398, 7, 398, 2, 399, 7, 399, 2, 400, 7, + 400, 2, 401, 7, 401, 2, 402, 7, 402, 2, 403, 7, 403, 2, 404, 7, 404, 2, + 405, 7, 405, 2, 406, 7, 406, 2, 407, 7, 407, 2, 408, 7, 408, 2, 409, 7, + 409, 2, 410, 7, 410, 2, 411, 7, 411, 2, 412, 7, 412, 2, 413, 7, 413, 2, + 414, 7, 414, 2, 415, 7, 415, 2, 416, 7, 416, 2, 417, 7, 417, 2, 418, 7, + 418, 2, 419, 7, 419, 2, 420, 7, 420, 2, 421, 7, 421, 2, 422, 7, 422, 2, + 423, 7, 423, 2, 424, 7, 424, 2, 425, 7, 425, 2, 426, 7, 426, 2, 427, 7, + 427, 2, 428, 7, 428, 2, 429, 7, 429, 2, 430, 7, 430, 2, 431, 7, 431, 2, + 432, 7, 432, 2, 433, 7, 433, 2, 434, 7, 434, 2, 435, 7, 435, 2, 436, 7, + 436, 2, 437, 7, 437, 2, 438, 7, 438, 2, 439, 7, 439, 2, 440, 7, 440, 2, + 441, 7, 441, 2, 442, 7, 442, 2, 443, 7, 443, 2, 444, 7, 444, 2, 445, 7, + 445, 2, 446, 7, 446, 2, 447, 7, 447, 2, 448, 7, 448, 2, 449, 7, 449, 2, + 450, 7, 450, 2, 451, 7, 451, 2, 452, 7, 452, 2, 453, 7, 453, 2, 454, 7, + 454, 2, 455, 7, 455, 2, 456, 7, 456, 2, 457, 7, 457, 2, 458, 7, 458, 2, + 459, 7, 459, 2, 460, 7, 460, 2, 461, 7, 461, 2, 462, 7, 462, 2, 463, 7, + 463, 2, 464, 7, 464, 2, 465, 7, 465, 2, 466, 7, 466, 2, 467, 7, 467, 2, + 468, 7, 468, 2, 469, 7, 469, 2, 470, 7, 470, 2, 471, 7, 471, 2, 472, 7, + 472, 2, 473, 7, 473, 2, 474, 7, 474, 2, 475, 7, 475, 2, 476, 7, 476, 2, + 477, 7, 477, 2, 478, 7, 478, 2, 479, 7, 479, 2, 480, 7, 480, 2, 481, 7, + 481, 2, 482, 7, 482, 2, 483, 7, 483, 2, 484, 7, 484, 2, 485, 7, 485, 2, + 486, 7, 486, 2, 487, 7, 487, 2, 488, 7, 488, 2, 489, 7, 489, 2, 490, 7, + 490, 2, 491, 7, 491, 2, 492, 7, 492, 2, 493, 7, 493, 2, 494, 7, 494, 2, + 495, 7, 495, 2, 496, 7, 496, 2, 497, 7, 497, 2, 498, 7, 498, 2, 499, 7, + 499, 2, 500, 7, 500, 2, 501, 7, 501, 2, 502, 7, 502, 2, 503, 7, 503, 2, + 504, 7, 504, 2, 505, 7, 505, 2, 506, 7, 506, 2, 507, 7, 507, 2, 508, 7, + 508, 2, 509, 7, 509, 2, 510, 7, 510, 2, 511, 7, 511, 2, 512, 7, 512, 2, + 513, 7, 513, 2, 514, 7, 514, 2, 515, 7, 515, 2, 516, 7, 516, 2, 517, 7, + 517, 2, 518, 7, 518, 2, 519, 7, 519, 2, 520, 7, 520, 2, 521, 7, 521, 2, + 522, 7, 522, 2, 523, 7, 523, 2, 524, 7, 524, 2, 525, 7, 525, 2, 526, 7, + 526, 2, 527, 7, 527, 2, 528, 7, 528, 2, 529, 7, 529, 2, 530, 7, 530, 2, + 531, 7, 531, 2, 532, 7, 532, 2, 533, 7, 533, 2, 534, 7, 534, 2, 535, 7, + 535, 2, 536, 7, 536, 2, 537, 7, 537, 2, 538, 7, 538, 2, 539, 7, 539, 2, + 540, 7, 540, 2, 541, 7, 541, 2, 542, 7, 542, 2, 543, 7, 543, 2, 544, 7, + 544, 2, 545, 7, 545, 2, 546, 7, 546, 2, 547, 7, 547, 2, 548, 7, 548, 2, + 549, 7, 549, 2, 550, 7, 550, 2, 551, 7, 551, 2, 552, 7, 552, 2, 553, 7, + 553, 2, 554, 7, 554, 2, 555, 7, 555, 2, 556, 7, 556, 2, 557, 7, 557, 2, + 558, 7, 558, 2, 559, 7, 559, 2, 560, 7, 560, 2, 561, 7, 561, 2, 562, 7, + 562, 2, 563, 7, 563, 2, 564, 7, 564, 2, 565, 7, 565, 2, 566, 7, 566, 2, + 567, 7, 567, 2, 568, 7, 568, 2, 569, 7, 569, 2, 570, 7, 570, 2, 571, 7, + 571, 2, 572, 7, 572, 2, 573, 7, 573, 2, 574, 7, 574, 2, 575, 7, 575, 2, + 576, 7, 576, 2, 577, 7, 577, 2, 578, 7, 578, 2, 579, 7, 579, 2, 580, 7, + 580, 2, 581, 7, 581, 2, 582, 7, 582, 2, 583, 7, 583, 2, 584, 7, 584, 2, + 585, 7, 585, 2, 586, 7, 586, 2, 587, 7, 587, 2, 588, 7, 588, 2, 589, 7, + 589, 2, 590, 7, 590, 2, 591, 7, 591, 2, 592, 7, 592, 2, 593, 7, 593, 2, + 594, 7, 594, 2, 595, 7, 595, 2, 596, 7, 596, 2, 597, 7, 597, 2, 598, 7, + 598, 2, 599, 7, 599, 2, 600, 7, 600, 2, 601, 7, 601, 2, 602, 7, 602, 2, + 603, 7, 603, 2, 604, 7, 604, 2, 605, 7, 605, 2, 606, 7, 606, 2, 607, 7, + 607, 2, 608, 7, 608, 2, 609, 7, 609, 2, 610, 7, 610, 2, 611, 7, 611, 2, + 612, 7, 612, 2, 613, 7, 613, 2, 614, 7, 614, 2, 615, 7, 615, 2, 616, 7, + 616, 2, 617, 7, 617, 2, 618, 7, 618, 2, 619, 7, 619, 2, 620, 7, 620, 2, + 621, 7, 621, 2, 622, 7, 622, 2, 623, 7, 623, 2, 624, 7, 624, 2, 625, 7, + 625, 2, 626, 7, 626, 2, 627, 7, 627, 2, 628, 7, 628, 2, 629, 7, 629, 2, + 630, 7, 630, 2, 631, 7, 631, 2, 632, 7, 632, 2, 633, 7, 633, 2, 634, 7, + 634, 2, 635, 7, 635, 2, 636, 7, 636, 2, 637, 7, 637, 2, 638, 7, 638, 2, + 639, 7, 639, 2, 640, 7, 640, 2, 641, 7, 641, 2, 642, 7, 642, 2, 643, 7, + 643, 2, 644, 7, 644, 2, 645, 7, 645, 2, 646, 7, 646, 2, 647, 7, 647, 2, + 648, 7, 648, 2, 649, 7, 649, 2, 650, 7, 650, 2, 651, 7, 651, 2, 652, 7, + 652, 2, 653, 7, 653, 2, 654, 7, 654, 2, 655, 7, 655, 2, 656, 7, 656, 2, + 657, 7, 657, 2, 658, 7, 658, 2, 659, 7, 659, 2, 660, 7, 660, 2, 661, 7, + 661, 2, 662, 7, 662, 2, 663, 7, 663, 2, 664, 7, 664, 2, 665, 7, 665, 2, + 666, 7, 666, 2, 667, 7, 667, 2, 668, 7, 668, 2, 669, 7, 669, 2, 670, 7, + 670, 2, 671, 7, 671, 2, 672, 7, 672, 2, 673, 7, 673, 2, 674, 7, 674, 2, + 675, 7, 675, 2, 676, 7, 676, 2, 677, 7, 677, 2, 678, 7, 678, 2, 679, 7, + 679, 2, 680, 7, 680, 2, 681, 7, 681, 2, 682, 7, 682, 2, 683, 7, 683, 2, + 684, 7, 684, 2, 685, 7, 685, 2, 686, 7, 686, 2, 687, 7, 687, 2, 688, 7, + 688, 2, 689, 7, 689, 2, 690, 7, 690, 2, 691, 7, 691, 2, 692, 7, 692, 2, + 693, 7, 693, 2, 694, 7, 694, 2, 695, 7, 695, 2, 696, 7, 696, 2, 697, 7, + 697, 2, 698, 7, 698, 2, 699, 7, 699, 2, 700, 7, 700, 2, 701, 7, 701, 2, + 702, 7, 702, 2, 703, 7, 703, 2, 704, 7, 704, 2, 705, 7, 705, 2, 706, 7, + 706, 2, 707, 7, 707, 2, 708, 7, 708, 2, 709, 7, 709, 2, 710, 7, 710, 2, + 711, 7, 711, 2, 712, 7, 712, 2, 713, 7, 713, 2, 714, 7, 714, 2, 715, 7, + 715, 2, 716, 7, 716, 2, 717, 7, 717, 2, 718, 7, 718, 2, 719, 7, 719, 2, + 720, 7, 720, 2, 721, 7, 721, 2, 722, 7, 722, 2, 723, 7, 723, 2, 724, 7, + 724, 2, 725, 7, 725, 2, 726, 7, 726, 2, 727, 7, 727, 2, 728, 7, 728, 2, + 729, 7, 729, 2, 730, 7, 730, 2, 731, 7, 731, 2, 732, 7, 732, 2, 733, 7, + 733, 2, 734, 7, 734, 2, 735, 7, 735, 2, 736, 7, 736, 2, 737, 7, 737, 2, + 738, 7, 738, 2, 739, 7, 739, 2, 740, 7, 740, 2, 741, 7, 741, 2, 742, 7, + 742, 2, 743, 7, 743, 2, 744, 7, 744, 2, 745, 7, 745, 2, 746, 7, 746, 2, + 747, 7, 747, 2, 748, 7, 748, 2, 749, 7, 749, 2, 750, 7, 750, 2, 751, 7, + 751, 2, 752, 7, 752, 2, 753, 7, 753, 2, 754, 7, 754, 2, 755, 7, 755, 2, + 756, 7, 756, 2, 757, 7, 757, 2, 758, 7, 758, 2, 759, 7, 759, 2, 760, 7, + 760, 2, 761, 7, 761, 2, 762, 7, 762, 2, 763, 7, 763, 2, 764, 7, 764, 2, + 765, 7, 765, 2, 766, 7, 766, 2, 767, 7, 767, 2, 768, 7, 768, 2, 769, 7, + 769, 2, 770, 7, 770, 2, 771, 7, 771, 2, 772, 7, 772, 2, 773, 7, 773, 2, + 774, 7, 774, 2, 775, 7, 775, 2, 776, 7, 776, 2, 777, 7, 777, 2, 778, 7, + 778, 2, 779, 7, 779, 2, 780, 7, 780, 2, 781, 7, 781, 2, 782, 7, 782, 2, + 783, 7, 783, 2, 784, 7, 784, 2, 785, 7, 785, 2, 786, 7, 786, 2, 787, 7, + 787, 2, 788, 7, 788, 2, 789, 7, 789, 2, 790, 7, 790, 2, 791, 7, 791, 2, + 792, 7, 792, 2, 793, 7, 793, 2, 794, 7, 794, 2, 795, 7, 795, 2, 796, 7, + 796, 2, 797, 7, 797, 2, 798, 7, 798, 2, 799, 7, 799, 2, 800, 7, 800, 2, + 801, 7, 801, 2, 802, 7, 802, 2, 803, 7, 803, 2, 804, 7, 804, 2, 805, 7, + 805, 2, 806, 7, 806, 2, 807, 7, 807, 2, 808, 7, 808, 2, 809, 7, 809, 2, + 810, 7, 810, 2, 811, 7, 811, 2, 812, 7, 812, 2, 813, 7, 813, 2, 814, 7, + 814, 2, 815, 7, 815, 2, 816, 7, 816, 2, 817, 7, 817, 2, 818, 7, 818, 2, + 819, 7, 819, 2, 820, 7, 820, 2, 821, 7, 821, 2, 822, 7, 822, 2, 823, 7, + 823, 2, 824, 7, 824, 2, 825, 7, 825, 2, 826, 7, 826, 2, 827, 7, 827, 2, + 828, 7, 828, 2, 829, 7, 829, 2, 830, 7, 830, 2, 831, 7, 831, 2, 832, 7, + 832, 2, 833, 7, 833, 2, 834, 7, 834, 2, 835, 7, 835, 2, 836, 7, 836, 2, + 837, 7, 837, 2, 838, 7, 838, 2, 839, 7, 839, 2, 840, 7, 840, 2, 841, 7, + 841, 2, 842, 7, 842, 2, 843, 7, 843, 2, 844, 7, 844, 2, 845, 7, 845, 2, + 846, 7, 846, 2, 847, 7, 847, 2, 848, 7, 848, 2, 849, 7, 849, 2, 850, 7, + 850, 2, 851, 7, 851, 2, 852, 7, 852, 2, 853, 7, 853, 2, 854, 7, 854, 2, + 855, 7, 855, 2, 856, 7, 856, 2, 857, 7, 857, 2, 858, 7, 858, 2, 859, 7, + 859, 2, 860, 7, 860, 2, 861, 7, 861, 2, 862, 7, 862, 2, 863, 7, 863, 2, + 864, 7, 864, 2, 865, 7, 865, 2, 866, 7, 866, 2, 867, 7, 867, 2, 868, 7, + 868, 2, 869, 7, 869, 2, 870, 7, 870, 2, 871, 7, 871, 2, 872, 7, 872, 2, + 873, 7, 873, 2, 874, 7, 874, 2, 875, 7, 875, 2, 876, 7, 876, 2, 877, 7, + 877, 2, 878, 7, 878, 2, 879, 7, 879, 2, 880, 7, 880, 2, 881, 7, 881, 2, + 882, 7, 882, 2, 883, 7, 883, 2, 884, 7, 884, 2, 885, 7, 885, 2, 886, 7, + 886, 2, 887, 7, 887, 2, 888, 7, 888, 2, 889, 7, 889, 2, 890, 7, 890, 2, + 891, 7, 891, 2, 892, 7, 892, 2, 893, 7, 893, 2, 894, 7, 894, 2, 895, 7, + 895, 2, 896, 7, 896, 2, 897, 7, 897, 2, 898, 7, 898, 2, 899, 7, 899, 2, + 900, 7, 900, 2, 901, 7, 901, 2, 902, 7, 902, 2, 903, 7, 903, 2, 904, 7, + 904, 2, 905, 7, 905, 2, 906, 7, 906, 2, 907, 7, 907, 2, 908, 7, 908, 2, + 909, 7, 909, 2, 910, 7, 910, 2, 911, 7, 911, 2, 912, 7, 912, 2, 913, 7, + 913, 2, 914, 7, 914, 2, 915, 7, 915, 2, 916, 7, 916, 2, 917, 7, 917, 2, + 918, 7, 918, 2, 919, 7, 919, 2, 920, 7, 920, 2, 921, 7, 921, 2, 922, 7, + 922, 2, 923, 7, 923, 2, 924, 7, 924, 2, 925, 7, 925, 2, 926, 7, 926, 2, + 927, 7, 927, 2, 928, 7, 928, 2, 929, 7, 929, 2, 930, 7, 930, 2, 931, 7, + 931, 2, 932, 7, 932, 2, 933, 7, 933, 2, 934, 7, 934, 2, 935, 7, 935, 2, + 936, 7, 936, 2, 937, 7, 937, 2, 938, 7, 938, 2, 939, 7, 939, 2, 940, 7, + 940, 2, 941, 7, 941, 2, 942, 7, 942, 2, 943, 7, 943, 2, 944, 7, 944, 2, + 945, 7, 945, 2, 946, 7, 946, 2, 947, 7, 947, 2, 948, 7, 948, 2, 949, 7, + 949, 2, 950, 7, 950, 2, 951, 7, 951, 2, 952, 7, 952, 2, 953, 7, 953, 2, + 954, 7, 954, 2, 955, 7, 955, 2, 956, 7, 956, 2, 957, 7, 957, 2, 958, 7, + 958, 2, 959, 7, 959, 2, 960, 7, 960, 2, 961, 7, 961, 2, 962, 7, 962, 2, + 963, 7, 963, 2, 964, 7, 964, 2, 965, 7, 965, 2, 966, 7, 966, 2, 967, 7, + 967, 2, 968, 7, 968, 2, 969, 7, 969, 2, 970, 7, 970, 2, 971, 7, 971, 2, + 972, 7, 972, 2, 973, 7, 973, 2, 974, 7, 974, 2, 975, 7, 975, 2, 976, 7, + 976, 2, 977, 7, 977, 2, 978, 7, 978, 2, 979, 7, 979, 2, 980, 7, 980, 2, + 981, 7, 981, 2, 982, 7, 982, 2, 983, 7, 983, 2, 984, 7, 984, 2, 985, 7, + 985, 2, 986, 7, 986, 2, 987, 7, 987, 2, 988, 7, 988, 2, 989, 7, 989, 2, + 990, 7, 990, 2, 991, 7, 991, 2, 992, 7, 992, 2, 993, 7, 993, 2, 994, 7, + 994, 2, 995, 7, 995, 2, 996, 7, 996, 2, 997, 7, 997, 2, 998, 7, 998, 2, + 999, 7, 999, 2, 1000, 7, 1000, 2, 1001, 7, 1001, 2, 1002, 7, 1002, 2, 1003, + 7, 1003, 2, 1004, 7, 1004, 2, 1005, 7, 1005, 2, 1006, 7, 1006, 2, 1007, + 7, 1007, 2, 1008, 7, 1008, 2, 1009, 7, 1009, 2, 1010, 7, 1010, 2, 1011, + 7, 1011, 2, 1012, 7, 1012, 2, 1013, 7, 1013, 2, 1014, 7, 1014, 2, 1015, + 7, 1015, 2, 1016, 7, 1016, 2, 1017, 7, 1017, 2, 1018, 7, 1018, 2, 1019, + 7, 1019, 2, 1020, 7, 1020, 2, 1021, 7, 1021, 2, 1022, 7, 1022, 2, 1023, + 7, 1023, 2, 1024, 7, 1024, 2, 1025, 7, 1025, 2, 1026, 7, 1026, 2, 1027, + 7, 1027, 2, 1028, 7, 1028, 2, 1029, 7, 1029, 2, 1030, 7, 1030, 2, 1031, + 7, 1031, 2, 1032, 7, 1032, 2, 1033, 7, 1033, 2, 1034, 7, 1034, 2, 1035, + 7, 1035, 2, 1036, 7, 1036, 2, 1037, 7, 1037, 2, 1038, 7, 1038, 2, 1039, + 7, 1039, 2, 1040, 7, 1040, 2, 1041, 7, 1041, 2, 1042, 7, 1042, 2, 1043, + 7, 1043, 2, 1044, 7, 1044, 2, 1045, 7, 1045, 2, 1046, 7, 1046, 2, 1047, + 7, 1047, 2, 1048, 7, 1048, 2, 1049, 7, 1049, 2, 1050, 7, 1050, 2, 1051, + 7, 1051, 2, 1052, 7, 1052, 2, 1053, 7, 1053, 2, 1054, 7, 1054, 2, 1055, + 7, 1055, 2, 1056, 7, 1056, 2, 1057, 7, 1057, 2, 1058, 7, 1058, 2, 1059, + 7, 1059, 2, 1060, 7, 1060, 2, 1061, 7, 1061, 2, 1062, 7, 1062, 2, 1063, + 7, 1063, 2, 1064, 7, 1064, 2, 1065, 7, 1065, 2, 1066, 7, 1066, 2, 1067, + 7, 1067, 2, 1068, 7, 1068, 2, 1069, 7, 1069, 2, 1070, 7, 1070, 2, 1071, + 7, 1071, 2, 1072, 7, 1072, 2, 1073, 7, 1073, 2, 1074, 7, 1074, 2, 1075, + 7, 1075, 2, 1076, 7, 1076, 2, 1077, 7, 1077, 2, 1078, 7, 1078, 2, 1079, + 7, 1079, 2, 1080, 7, 1080, 2, 1081, 7, 1081, 2, 1082, 7, 1082, 2, 1083, + 7, 1083, 2, 1084, 7, 1084, 2, 1085, 7, 1085, 2, 1086, 7, 1086, 2, 1087, + 7, 1087, 2, 1088, 7, 1088, 2, 1089, 7, 1089, 2, 1090, 7, 1090, 2, 1091, + 7, 1091, 2, 1092, 7, 1092, 2, 1093, 7, 1093, 2, 1094, 7, 1094, 2, 1095, + 7, 1095, 2, 1096, 7, 1096, 2, 1097, 7, 1097, 2, 1098, 7, 1098, 2, 1099, + 7, 1099, 2, 1100, 7, 1100, 2, 1101, 7, 1101, 2, 1102, 7, 1102, 2, 1103, + 7, 1103, 2, 1104, 7, 1104, 2, 1105, 7, 1105, 2, 1106, 7, 1106, 2, 1107, + 7, 1107, 2, 1108, 7, 1108, 2, 1109, 7, 1109, 2, 1110, 7, 1110, 2, 1111, + 7, 1111, 2, 1112, 7, 1112, 2, 1113, 7, 1113, 2, 1114, 7, 1114, 2, 1115, + 7, 1115, 2, 1116, 7, 1116, 2, 1117, 7, 1117, 2, 1118, 7, 1118, 2, 1119, + 7, 1119, 2, 1120, 7, 1120, 2, 1121, 7, 1121, 2, 1122, 7, 1122, 2, 1123, + 7, 1123, 2, 1124, 7, 1124, 2, 1125, 7, 1125, 2, 1126, 7, 1126, 2, 1127, + 7, 1127, 2, 1128, 7, 1128, 2, 1129, 7, 1129, 2, 1130, 7, 1130, 2, 1131, + 7, 1131, 2, 1132, 7, 1132, 2, 1133, 7, 1133, 2, 1134, 7, 1134, 2, 1135, + 7, 1135, 2, 1136, 7, 1136, 2, 1137, 7, 1137, 2, 1138, 7, 1138, 2, 1139, + 7, 1139, 2, 1140, 7, 1140, 2, 1141, 7, 1141, 2, 1142, 7, 1142, 2, 1143, + 7, 1143, 2, 1144, 7, 1144, 2, 1145, 7, 1145, 2, 1146, 7, 1146, 2, 1147, + 7, 1147, 2, 1148, 7, 1148, 2, 1149, 7, 1149, 2, 1150, 7, 1150, 2, 1151, + 7, 1151, 2, 1152, 7, 1152, 2, 1153, 7, 1153, 2, 1154, 7, 1154, 2, 1155, + 7, 1155, 2, 1156, 7, 1156, 2, 1157, 7, 1157, 2, 1158, 7, 1158, 2, 1159, + 7, 1159, 2, 1160, 7, 1160, 2, 1161, 7, 1161, 2, 1162, 7, 1162, 2, 1163, + 7, 1163, 2, 1164, 7, 1164, 2, 1165, 7, 1165, 2, 1166, 7, 1166, 2, 1167, + 7, 1167, 2, 1168, 7, 1168, 2, 1169, 7, 1169, 2, 1170, 7, 1170, 2, 1171, + 7, 1171, 2, 1172, 7, 1172, 2, 1173, 7, 1173, 2, 1174, 7, 1174, 2, 1175, + 7, 1175, 2, 1176, 7, 1176, 1, 0, 4, 0, 2357, 8, 0, 11, 0, 12, 0, 2358, + 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4, 1, 2368, 8, 1, 11, 1, 12, + 1, 2369, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 2, 1, 2, 5, 2, 2381, + 8, 2, 10, 2, 12, 2, 2384, 9, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 3, 1, + 3, 1, 3, 1, 3, 5, 3, 2395, 8, 3, 10, 3, 12, 3, 2398, 9, 3, 1, 3, 3, 3, + 2401, 8, 3, 1, 3, 5, 3, 2404, 8, 3, 10, 3, 12, 3, 2407, 9, 3, 1, 3, 3, + 3, 2410, 8, 3, 1, 3, 1, 3, 3, 3, 2414, 8, 3, 1, 3, 1, 3, 1, 3, 1, 3, 3, + 3, 2420, 8, 3, 1, 3, 1, 3, 3, 3, 2424, 8, 3, 3, 3, 2426, 8, 3, 1, 3, 1, + 3, 1, 4, 1, 4, 1, 4, 1, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 6, 1, 6, 1, 6, 1, + 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, + 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, + 1, 10, 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 1, 12, 1, + 12, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, + 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 1, + 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 17, + 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, + 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, + 1, 20, 1, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 22, 1, 22, 1, 22, 1, + 22, 1, 22, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 24, 1, 24, + 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 25, 1, 25, 1, + 25, 1, 25, 1, 25, 1, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, + 1, 26, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 28, 1, 28, 1, + 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 29, 1, 29, 1, 29, + 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 30, 1, 30, 1, + 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, 1, 31, + 1, 31, 1, 31, 1, 31, 1, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, + 32, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 34, 1, 34, 1, 34, 1, 34, + 1, 34, 1, 34, 1, 34, 1, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, + 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 36, + 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 37, 1, + 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, + 1, 38, 1, 38, 1, 38, 1, 38, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, + 39, 1, 39, 1, 39, 1, 39, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, + 1, 40, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 42, 1, + 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 43, 1, 43, + 1, 43, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 45, 1, 45, 1, + 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 46, 1, 46, 1, 46, 1, 46, + 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, + 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, + 1, 47, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, + 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, + 1, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 51, 1, 51, 1, 51, 1, 51, 1, + 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, + 1, 53, 1, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, + 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 1, 56, + 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, + 57, 1, 57, 1, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 59, + 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 60, 1, 60, 1, 60, 1, 60, 1, + 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 62, 1, 62, + 1, 62, 1, 62, 1, 62, 1, 62, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, + 64, 1, 64, 1, 64, 1, 64, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 66, + 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 67, 1, 67, 1, 67, 1, + 67, 1, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, + 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, + 70, 1, 70, 1, 70, 1, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 72, + 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, + 73, 1, 73, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, + 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, + 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 76, 1, 76, 1, 76, 1, 77, 1, 77, 1, 77, + 1, 77, 1, 77, 1, 77, 1, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, + 78, 1, 78, 1, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, + 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 82, 1, 82, 1, 82, 1, + 82, 1, 82, 1, 82, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 84, 1, 84, + 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, + 85, 1, 85, 1, 85, 1, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 87, 1, 87, + 1, 87, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 89, 1, + 89, 1, 89, 1, 89, 1, 89, 1, 90, 1, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, + 1, 91, 1, 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 93, 1, 93, 1, 93, 1, + 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, + 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 96, 1, 96, 1, + 96, 1, 96, 1, 96, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 98, 1, 98, 1, 98, + 1, 98, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, + 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 101, 1, 101, 1, 101, 1, + 101, 1, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 103, 1, 103, 1, + 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, + 104, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, + 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 106, 1, 106, 1, 106, 1, 106, 1, + 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 107, 1, + 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, + 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, + 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, + 107, 1, 107, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 109, 1, + 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 110, 1, + 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 111, 1, + 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 112, 1, + 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 113, 1, 113, 1, + 113, 1, 113, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, + 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, + 114, 1, 114, 1, 114, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 116, 1, + 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 117, 1, 117, 1, 117, 1, + 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, + 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 120, 1, 120, 1, + 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 121, 1, 121, 1, + 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, + 122, 1, 122, 1, 122, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, + 124, 1, 124, 1, 124, 1, 124, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, + 125, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, + 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 128, 1, 128, 1, 128, 1, 128, 1, + 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 129, 1, 129, 1, 129, 1, + 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 130, 1, 130, 1, 130, 1, 130, 1, + 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 131, 1, 131, 1, 131, 1, + 131, 1, 131, 1, 131, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, + 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 134, 1, 134, 1, 134, 1, 134, 1, + 134, 1, 134, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, + 135, 1, 135, 1, 135, 1, 135, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, + 136, 1, 136, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, + 137, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 139, 1, + 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 140, 1, 140, 1, 140, 1, + 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 141, 1, 141, 1, 141, 1, 141, 1, + 141, 1, 141, 1, 141, 1, 141, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, + 142, 1, 142, 1, 142, 1, 142, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, + 143, 1, 143, 1, 143, 1, 143, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, + 144, 1, 144, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, + 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 147, 1, 147, 1, + 147, 1, 147, 1, 147, 1, 147, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, + 148, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 150, 1, + 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 151, 1, 151, 1, + 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 152, 1, 152, 1, 152, 1, 152, 1, + 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, + 153, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 155, 1, 155, 1, 155, 1, + 155, 1, 155, 1, 155, 1, 155, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, + 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, + 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, + 157, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, + 159, 1, 159, 1, 159, 1, 159, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, + 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 161, 1, + 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 162, 1, + 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, + 162, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, + 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 164, 1, 164, 1, + 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, + 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, + 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, + 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 166, 1, + 166, 1, 166, 1, 166, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, + 167, 1, 167, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, + 168, 1, 168, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, + 169, 1, 169, 1, 169, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, + 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 171, 1, + 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 172, 1, 172, 1, 172, 1, 172, 1, + 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 173, 1, 173, 1, + 173, 1, 173, 1, 173, 1, 174, 1, 174, 1, 174, 1, 175, 1, 175, 1, 175, 1, + 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 176, 1, 176, 1, 176, 1, + 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 177, 1, 177, 1, 177, 1, 177, 1, + 177, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 179, 1, 179, 1, 179, 1, + 179, 1, 179, 1, 179, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, + 180, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 182, 1, + 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 183, 1, + 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 184, 1, 184, 1, 184, 1, + 184, 1, 184, 1, 184, 1, 185, 1, 185, 1, 185, 1, 185, 1, 186, 1, 186, 1, + 186, 1, 186, 1, 186, 1, 186, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, + 187, 1, 187, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 189, 1, 189, 1, + 189, 1, 189, 1, 189, 1, 189, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, + 190, 1, 191, 1, 191, 1, 191, 1, 191, 1, 191, 1, 192, 1, 192, 1, 192, 1, + 192, 1, 192, 1, 192, 1, 193, 1, 193, 1, 193, 1, 193, 1, 194, 1, 194, 1, + 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 195, 1, 195, 1, + 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 196, 1, 196, 1, 196, 1, + 196, 1, 196, 1, 196, 1, 196, 1, 196, 1, 196, 1, 197, 1, 197, 1, 197, 1, + 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 198, 1, 198, 1, + 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 199, 1, + 199, 1, 199, 1, 199, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 201, 1, + 201, 1, 201, 1, 201, 1, 201, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, + 203, 1, 203, 1, 203, 1, 203, 1, 203, 1, 204, 1, 204, 1, 204, 1, 204, 1, + 204, 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, 1, + 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 207, 1, 207, 1, + 207, 1, 207, 1, 207, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, + 208, 1, 209, 1, 209, 1, 209, 1, 209, 1, 209, 1, 209, 1, 209, 1, 209, 1, + 209, 1, 209, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 211, 1, + 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 212, 1, 212, 1, 212, 1, + 212, 1, 212, 1, 212, 1, 212, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, + 213, 1, 213, 1, 213, 1, 214, 1, 214, 1, 214, 1, 214, 1, 215, 1, 215, 1, + 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 216, 1, 216, 1, 216, 1, + 216, 1, 216, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 218, 1, 218, 1, + 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 219, 1, + 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 220, 1, + 220, 1, 220, 1, 220, 1, 220, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, + 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 223, 1, + 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 224, 1, + 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 225, 1, + 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 226, 1, 226, 1, 226, 1, + 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 227, 1, 227, 1, + 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 228, 1, 228, 1, + 228, 1, 228, 1, 228, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, + 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 230, 1, 230, 1, 230, 1, 230, 1, + 230, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, + 231, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, + 232, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 234, 1, 234, 1, 234, 1, + 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 235, 1, + 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 236, 1, + 236, 1, 236, 1, 236, 1, 236, 1, 237, 1, 237, 1, 237, 1, 237, 1, 237, 1, + 237, 1, 237, 1, 237, 1, 238, 1, 238, 1, 238, 1, 238, 1, 238, 1, 238, 1, + 238, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 240, 1, + 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, + 240, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, + 241, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, + 242, 1, 242, 1, 242, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, + 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 244, 1, 244, 1, 244, 1, 244, 1, + 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 245, 1, + 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, + 245, 1, 245, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, + 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 247, 1, 247, 1, + 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, + 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 248, 1, + 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, + 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, + 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, + 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 250, 1, + 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, + 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 251, 1, 251, 1, 251, 1, + 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 252, 1, + 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, + 252, 1, 252, 1, 252, 1, 252, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, + 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, + 253, 1, 253, 1, 253, 1, 253, 1, 254, 1, 254, 1, 254, 1, 254, 1, 254, 1, + 254, 1, 254, 1, 254, 1, 254, 1, 254, 1, 254, 1, 254, 1, 254, 1, 254, 1, + 254, 1, 254, 1, 254, 1, 254, 1, 255, 1, 255, 1, 255, 1, 255, 1, 255, 1, + 255, 1, 255, 1, 255, 1, 255, 1, 255, 1, 255, 1, 255, 1, 255, 1, 255, 1, + 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, + 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, + 256, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, + 257, 1, 257, 1, 257, 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, 1, + 258, 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, 1, 259, 1, 259, 1, + 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, + 259, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, + 260, 1, 260, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, + 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 262, 1, 262, 1, 262, 1, 262, 1, + 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 263, 1, 263, 1, + 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, + 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 264, 1, 264, 1, 264, 1, + 264, 1, 264, 1, 264, 1, 264, 1, 264, 1, 264, 1, 264, 1, 264, 1, 264, 1, + 264, 1, 264, 1, 264, 1, 264, 1, 264, 1, 264, 1, 264, 1, 264, 1, 265, 1, + 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, + 265, 1, 265, 1, 266, 1, 266, 1, 266, 1, 266, 1, 266, 1, 266, 1, 266, 1, + 266, 1, 266, 1, 266, 1, 266, 1, 266, 1, 266, 1, 266, 1, 266, 1, 267, 1, + 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, + 267, 1, 267, 1, 267, 1, 267, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, + 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 269, 1, 269, 1, + 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, + 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, + 270, 1, 270, 1, 270, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, + 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 272, 1, 272, 1, + 272, 1, 272, 1, 272, 1, 272, 1, 272, 1, 272, 1, 272, 1, 272, 1, 272, 1, + 272, 1, 272, 1, 272, 1, 272, 1, 272, 1, 272, 1, 272, 1, 273, 1, 273, 1, + 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, + 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, + 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, + 273, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, + 274, 1, 274, 1, 274, 1, 274, 1, 275, 1, 275, 1, 275, 1, 275, 1, 275, 1, + 275, 1, 275, 1, 275, 1, 275, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, + 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, + 276, 1, 276, 1, 276, 1, 276, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, + 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, + 277, 1, 277, 1, 277, 1, 277, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, + 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 279, 1, 279, 1, 279, 1, + 279, 1, 279, 1, 279, 1, 279, 1, 279, 1, 279, 1, 279, 1, 280, 1, 280, 1, + 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, + 280, 1, 280, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, + 281, 1, 281, 1, 281, 1, 281, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, + 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 283, 1, 283, 1, 283, 1, + 283, 1, 283, 1, 283, 1, 283, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, + 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 285, 1, 285, 1, 285, 1, + 285, 1, 285, 1, 286, 1, 286, 1, 286, 1, 286, 1, 287, 1, 287, 1, 287, 1, + 287, 1, 287, 1, 287, 1, 287, 1, 287, 1, 288, 1, 288, 1, 288, 1, 288, 1, + 288, 1, 288, 1, 288, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, + 289, 1, 289, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 291, 1, + 291, 1, 291, 1, 291, 1, 291, 1, 291, 1, 291, 1, 291, 1, 291, 1, 291, 1, + 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, + 292, 1, 292, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, + 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 294, 1, 294, 1, 294, 1, 294, 1, + 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, + 295, 1, 295, 1, 295, 1, 295, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, + 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 297, 1, 297, 1, 297, 1, + 297, 1, 297, 1, 298, 1, 298, 1, 298, 1, 298, 1, 299, 1, 299, 1, 299, 1, + 299, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 301, 1, 301, 1, + 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 302, 1, + 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, + 302, 1, 302, 1, 302, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 304, 1, + 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, + 304, 1, 305, 1, 305, 1, 305, 1, 305, 1, 306, 1, 306, 1, 306, 1, 306, 1, + 306, 1, 306, 1, 306, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, + 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 308, 1, 308, 1, 308, 1, 308, 1, + 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 309, 1, + 309, 1, 309, 1, 309, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, + 310, 1, 310, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, + 311, 1, 311, 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 1, + 312, 1, 312, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, + 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 314, 1, 314, 1, 314, 1, + 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, + 314, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, + 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, + 315, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, + 316, 1, 316, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, + 317, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, + 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, + 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, + 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, 322, 1, + 322, 1, 322, 1, 322, 1, 322, 1, 322, 1, 322, 1, 322, 1, 322, 1, 322, 1, + 322, 1, 322, 1, 322, 1, 322, 1, 322, 1, 323, 1, 323, 1, 323, 1, 323, 1, + 324, 1, 324, 1, 324, 1, 324, 1, 324, 1, 324, 1, 324, 1, 324, 1, 324, 1, + 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 326, 1, 326, 1, + 326, 1, 326, 1, 326, 1, 326, 1, 326, 1, 326, 1, 326, 1, 326, 1, 327, 1, + 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, 328, 1, 328, 1, + 328, 1, 328, 1, 328, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, + 329, 1, 329, 1, 329, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 1, + 330, 1, 330, 1, 330, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, + 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 332, 1, + 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 333, 1, 333, 1, + 333, 1, 333, 1, 333, 1, 333, 1, 333, 1, 334, 1, 334, 1, 334, 1, 334, 1, + 334, 1, 334, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, + 335, 1, 335, 1, 335, 1, 336, 1, 336, 1, 336, 1, 336, 1, 336, 1, 336, 1, + 336, 1, 336, 1, 336, 1, 336, 1, 337, 1, 337, 1, 337, 1, 337, 1, 338, 1, + 338, 1, 338, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, + 339, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, + 340, 1, 340, 1, 340, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, + 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, + 341, 1, 342, 1, 342, 1, 342, 1, 342, 1, 342, 1, 342, 1, 342, 1, 342, 1, + 342, 1, 342, 1, 342, 1, 342, 1, 342, 1, 342, 1, 342, 1, 343, 1, 343, 1, + 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, + 343, 1, 343, 1, 343, 1, 343, 1, 344, 1, 344, 1, 344, 1, 344, 1, 344, 1, + 344, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 346, 1, + 346, 1, 346, 1, 346, 1, 347, 1, 347, 1, 347, 1, 347, 1, 347, 1, 347, 1, + 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 349, 1, 349, 1, 349, 1, 349, 1, + 349, 1, 349, 1, 349, 1, 349, 1, 350, 1, 350, 1, 350, 1, 350, 1, 350, 1, + 350, 1, 351, 1, 351, 1, 351, 1, 351, 1, 351, 1, 351, 1, 352, 1, 352, 1, + 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 353, 1, 353, 1, + 353, 1, 353, 1, 353, 1, 353, 1, 354, 1, 354, 1, 354, 1, 354, 1, 354, 1, + 354, 1, 354, 1, 354, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, + 355, 1, 355, 1, 356, 1, 356, 1, 356, 1, 356, 1, 356, 1, 356, 1, 356, 1, + 356, 1, 356, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, + 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 358, 1, 358, 1, + 358, 1, 358, 1, 358, 1, 358, 1, 358, 1, 359, 1, 359, 1, 359, 1, 359, 1, + 359, 1, 359, 1, 359, 1, 359, 1, 359, 1, 359, 1, 359, 1, 359, 1, 359, 1, + 360, 1, 360, 1, 360, 1, 360, 1, 360, 1, 360, 1, 360, 1, 361, 1, 361, 1, + 361, 1, 361, 1, 361, 1, 361, 1, 362, 1, 362, 1, 362, 1, 362, 1, 362, 1, + 362, 1, 362, 1, 362, 1, 362, 1, 362, 1, 362, 1, 363, 1, 363, 1, 363, 1, + 363, 1, 363, 1, 363, 1, 363, 1, 363, 1, 363, 1, 364, 1, 364, 1, 364, 1, + 364, 1, 364, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, + 365, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, + 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 367, 1, 367, 1, 367, 1, + 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, + 368, 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, 1, 369, 1, + 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 370, 1, 370, 1, 370, 1, + 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 371, 1, 371, 1, 371, 1, 371, 1, + 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 372, 1, 372, 1, + 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, + 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, + 373, 1, 373, 1, 373, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, + 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 375, 1, 375, 1, 375, 1, 375, 1, + 375, 1, 375, 1, 375, 1, 375, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, + 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 377, 1, 377, 1, 377, 1, + 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 378, 1, + 378, 1, 378, 1, 378, 1, 378, 1, 378, 1, 378, 1, 378, 1, 378, 1, 378, 1, + 378, 1, 378, 1, 378, 1, 378, 1, 378, 1, 378, 1, 378, 1, 378, 1, 378, 1, + 379, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, 1, + 379, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, 1, + 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, + 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 381, 1, 381, 1, + 381, 1, 381, 1, 381, 1, 381, 1, 381, 1, 381, 1, 381, 1, 382, 1, 382, 1, + 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 383, 1, 383, 1, 383, 1, + 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, + 383, 1, 384, 1, 384, 1, 384, 1, 384, 1, 384, 1, 385, 1, 385, 1, 385, 1, + 385, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 387, 1, 387, 1, + 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, + 387, 1, 388, 1, 388, 1, 388, 1, 388, 1, 388, 1, 389, 1, 389, 1, 389, 1, + 389, 1, 389, 1, 389, 1, 389, 1, 389, 1, 389, 1, 390, 1, 390, 1, 390, 1, + 390, 1, 390, 1, 390, 1, 390, 1, 390, 1, 390, 1, 390, 1, 390, 1, 391, 1, + 391, 1, 391, 1, 391, 1, 391, 1, 391, 1, 391, 1, 391, 1, 391, 1, 391, 1, + 391, 1, 391, 1, 391, 1, 392, 1, 392, 1, 392, 1, 392, 1, 392, 1, 392, 1, + 392, 1, 392, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, + 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, + 394, 1, 394, 1, 394, 1, 394, 1, 394, 1, 394, 1, 394, 1, 394, 1, 394, 1, + 394, 1, 394, 1, 394, 1, 394, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, + 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 396, 1, 396, 1, 396, 1, 396, 1, + 396, 1, 396, 1, 396, 1, 396, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, + 397, 1, 397, 1, 397, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 399, 1, + 399, 1, 399, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, + 400, 1, 400, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, + 401, 1, 401, 1, 401, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 1, + 402, 1, 402, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, + 404, 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, 1, + 404, 1, 405, 1, 405, 1, 405, 1, 405, 1, 405, 1, 405, 1, 405, 1, 405, 1, + 405, 1, 405, 1, 405, 1, 406, 1, 406, 1, 406, 1, 406, 1, 406, 1, 406, 1, + 406, 1, 406, 1, 406, 1, 406, 1, 406, 1, 406, 1, 406, 1, 406, 1, 406, 1, + 406, 1, 406, 1, 406, 1, 407, 1, 407, 1, 407, 1, 407, 1, 408, 1, 408, 1, + 408, 1, 408, 1, 408, 1, 409, 1, 409, 1, 409, 1, 409, 1, 409, 1, 409, 1, + 409, 1, 410, 1, 410, 1, 410, 1, 410, 1, 410, 1, 410, 1, 410, 1, 410, 1, + 411, 1, 411, 1, 411, 1, 411, 1, 411, 1, 411, 1, 412, 1, 412, 1, 412, 1, + 412, 1, 412, 1, 412, 1, 412, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, + 413, 1, 413, 1, 414, 1, 414, 1, 414, 1, 414, 1, 414, 1, 415, 1, 415, 1, + 415, 1, 415, 1, 415, 1, 415, 1, 416, 1, 416, 1, 416, 1, 416, 1, 416, 1, + 416, 1, 416, 1, 417, 1, 417, 1, 417, 1, 417, 1, 417, 1, 417, 1, 418, 1, + 418, 1, 418, 1, 418, 1, 418, 1, 418, 1, 418, 1, 418, 1, 418, 1, 419, 1, + 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, + 420, 1, 420, 1, 420, 1, 420, 1, 420, 1, 420, 1, 420, 1, 421, 1, 421, 1, + 421, 1, 421, 1, 421, 1, 421, 1, 421, 1, 422, 1, 422, 1, 422, 1, 422, 1, + 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 423, 1, 423, 1, 423, 1, 423, 1, + 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 424, 1, + 424, 1, 424, 1, 424, 1, 424, 1, 424, 1, 424, 1, 424, 1, 424, 1, 424, 1, + 424, 1, 424, 1, 424, 1, 424, 1, 424, 1, 424, 1, 424, 1, 424, 1, 424, 1, + 424, 1, 424, 1, 424, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 426, 1, + 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 427, 1, 427, 1, 427, 1, + 427, 1, 427, 1, 427, 1, 427, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, + 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, + 428, 1, 428, 1, 429, 1, 429, 1, 429, 1, 429, 1, 429, 1, 429, 1, 429, 1, + 430, 1, 430, 1, 430, 1, 430, 1, 430, 1, 430, 1, 431, 1, 431, 1, 431, 1, + 431, 1, 431, 1, 431, 1, 432, 1, 432, 1, 432, 1, 432, 1, 432, 1, 432, 1, + 433, 1, 433, 1, 433, 1, 433, 1, 433, 1, 433, 1, 433, 1, 433, 1, 433, 1, + 433, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, + 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 436, 1, 436, 1, 436, 1, + 436, 1, 436, 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, 1, + 437, 1, 437, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, + 438, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, 440, 1, + 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 441, 1, 441, 1, 441, 1, + 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, + 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 442, 1, 442, 1, 442, 1, + 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 443, 1, 443, 1, 443, 1, 443, 1, + 443, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 445, 1, 445, 1, 445, 1, + 445, 1, 445, 1, 445, 1, 445, 1, 445, 1, 446, 1, 446, 1, 446, 1, 446, 1, + 446, 1, 447, 1, 447, 1, 447, 1, 447, 1, 447, 1, 447, 1, 448, 1, 448, 1, + 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, + 449, 1, 449, 1, 449, 1, 449, 1, 449, 1, 449, 1, 449, 1, 449, 1, 449, 1, + 449, 1, 449, 1, 449, 1, 449, 1, 449, 1, 449, 1, 449, 1, 449, 1, 449, 1, + 450, 1, 450, 1, 450, 1, 450, 1, 450, 1, 450, 1, 450, 1, 451, 1, 451, 1, + 451, 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, 1, 452, 1, + 452, 1, 452, 1, 452, 1, 452, 1, 452, 1, 452, 1, 452, 1, 453, 1, 453, 1, + 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, + 453, 1, 453, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, + 454, 1, 455, 1, 455, 1, 455, 1, 455, 1, 455, 1, 455, 1, 455, 1, 455, 1, + 455, 1, 455, 1, 455, 1, 455, 1, 455, 1, 455, 1, 456, 1, 456, 1, 456, 1, + 456, 1, 456, 1, 456, 1, 456, 1, 456, 1, 457, 1, 457, 1, 457, 1, 457, 1, + 457, 1, 457, 1, 457, 1, 457, 1, 457, 1, 458, 1, 458, 1, 458, 1, 458, 1, + 458, 1, 458, 1, 458, 1, 458, 1, 459, 1, 459, 1, 459, 1, 459, 1, 459, 1, + 459, 1, 459, 1, 459, 1, 459, 1, 459, 1, 460, 1, 460, 1, 460, 1, 460, 1, + 460, 1, 460, 1, 460, 1, 460, 1, 461, 1, 461, 1, 461, 1, 462, 1, 462, 1, + 462, 1, 462, 1, 462, 1, 462, 1, 462, 1, 462, 1, 462, 1, 462, 1, 463, 1, + 463, 1, 463, 1, 463, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, + 464, 1, 464, 1, 464, 1, 464, 1, 465, 1, 465, 1, 465, 1, 465, 1, 465, 1, + 465, 1, 465, 1, 466, 1, 466, 1, 466, 1, 466, 1, 466, 1, 467, 1, 467, 1, + 467, 1, 467, 1, 467, 1, 467, 1, 467, 1, 467, 1, 467, 1, 467, 1, 467, 1, + 467, 1, 467, 1, 467, 1, 467, 1, 468, 1, 468, 1, 468, 1, 468, 1, 468, 1, + 468, 1, 468, 1, 468, 1, 468, 1, 469, 1, 469, 1, 469, 1, 469, 1, 469, 1, + 470, 1, 470, 1, 470, 1, 470, 1, 470, 1, 470, 1, 470, 1, 471, 1, 471, 1, + 471, 1, 471, 1, 471, 1, 472, 1, 472, 1, 472, 1, 472, 1, 472, 1, 472, 1, + 473, 1, 473, 1, 473, 1, 473, 1, 473, 1, 474, 1, 474, 1, 474, 1, 474, 1, + 474, 1, 474, 1, 475, 1, 475, 1, 475, 1, 475, 1, 475, 1, 475, 1, 475, 1, + 475, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 477, 1, 477, 1, 477, 1, + 477, 1, 477, 1, 477, 1, 477, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, + 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, + 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 479, 1, 479, 1, + 479, 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, 1, + 479, 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, 1, + 479, 1, 480, 1, 480, 1, 480, 1, 480, 1, 480, 1, 480, 1, 480, 1, 480, 1, + 480, 1, 480, 1, 480, 1, 480, 1, 480, 1, 481, 1, 481, 1, 481, 1, 481, 1, + 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, + 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, + 481, 1, 481, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, + 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 483, 1, 483, 1, 483, 1, 483, 1, + 483, 1, 483, 1, 483, 1, 483, 1, 483, 1, 483, 1, 483, 1, 483, 1, 483, 1, + 483, 1, 483, 1, 483, 1, 484, 1, 484, 1, 484, 1, 484, 1, 484, 1, 484, 1, + 484, 1, 484, 1, 484, 1, 484, 1, 484, 1, 484, 1, 484, 1, 484, 1, 484, 1, + 485, 1, 485, 1, 485, 1, 485, 1, 485, 1, 485, 1, 485, 1, 485, 1, 485, 1, + 485, 1, 485, 1, 485, 1, 485, 1, 485, 1, 485, 1, 485, 1, 486, 1, 486, 1, + 486, 1, 486, 1, 486, 1, 486, 1, 486, 1, 486, 1, 486, 1, 486, 1, 486, 1, + 486, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, + 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, + 487, 1, 487, 1, 488, 1, 488, 1, 488, 1, 488, 1, 488, 1, 488, 1, 488, 1, + 488, 1, 488, 1, 488, 1, 488, 1, 489, 1, 489, 1, 489, 1, 489, 1, 489, 1, + 489, 1, 489, 1, 489, 1, 489, 1, 489, 1, 489, 1, 489, 1, 489, 1, 489, 1, + 490, 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, 1, + 490, 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, 1, + 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, + 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 492, 1, 492, 1, + 492, 1, 492, 1, 492, 1, 492, 1, 492, 1, 492, 1, 492, 1, 492, 1, 492, 1, + 492, 1, 492, 1, 492, 1, 492, 1, 492, 1, 492, 1, 492, 1, 493, 1, 493, 1, + 493, 1, 493, 1, 493, 1, 493, 1, 493, 1, 493, 1, 493, 1, 493, 1, 493, 1, + 493, 1, 493, 1, 493, 1, 493, 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, 1, + 494, 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, 1, + 494, 1, 494, 1, 494, 1, 494, 1, 494, 1, 495, 1, 495, 1, 495, 1, 495, 1, + 495, 1, 495, 1, 495, 1, 495, 1, 495, 1, 495, 1, 495, 1, 495, 1, 495, 1, + 495, 1, 495, 1, 496, 1, 496, 1, 496, 1, 496, 1, 496, 1, 496, 1, 496, 1, + 496, 1, 496, 1, 496, 1, 496, 1, 496, 1, 496, 1, 496, 1, 496, 1, 496, 1, + 496, 1, 496, 1, 496, 1, 497, 1, 497, 1, 497, 1, 497, 1, 497, 1, 497, 1, + 497, 1, 497, 1, 497, 1, 497, 1, 497, 1, 497, 1, 498, 1, 498, 1, 498, 1, + 498, 1, 498, 1, 498, 1, 498, 1, 498, 1, 498, 1, 498, 1, 498, 1, 498, 1, + 498, 1, 498, 1, 498, 1, 498, 1, 498, 1, 498, 1, 498, 1, 498, 1, 498, 1, + 498, 1, 498, 1, 498, 1, 498, 1, 499, 1, 499, 1, 499, 1, 499, 1, 499, 1, + 499, 1, 499, 1, 499, 1, 499, 1, 499, 1, 499, 1, 499, 1, 499, 1, 499, 1, + 499, 1, 499, 1, 499, 1, 499, 1, 499, 1, 499, 1, 499, 1, 500, 1, 500, 1, + 500, 1, 500, 1, 500, 1, 500, 1, 500, 1, 500, 1, 500, 1, 501, 1, 501, 1, + 501, 1, 501, 1, 501, 1, 501, 1, 501, 1, 501, 1, 501, 1, 502, 1, 502, 1, + 502, 1, 502, 1, 502, 1, 502, 1, 502, 1, 502, 1, 502, 1, 502, 1, 502, 1, + 502, 1, 502, 1, 502, 1, 502, 1, 502, 1, 502, 1, 502, 1, 502, 1, 502, 1, + 502, 1, 503, 1, 503, 1, 503, 1, 503, 1, 503, 1, 503, 1, 503, 1, 503, 1, + 503, 1, 503, 1, 503, 1, 503, 1, 503, 1, 503, 1, 503, 1, 503, 1, 503, 1, + 503, 1, 503, 1, 503, 1, 503, 1, 504, 1, 504, 1, 504, 1, 504, 1, 504, 1, + 504, 1, 504, 1, 505, 1, 505, 1, 505, 1, 505, 1, 505, 1, 505, 1, 505, 1, + 506, 1, 506, 1, 506, 1, 506, 1, 506, 1, 506, 1, 507, 1, 507, 1, 507, 1, + 507, 1, 507, 1, 507, 1, 507, 1, 507, 1, 507, 1, 507, 1, 507, 1, 507, 1, + 507, 1, 508, 1, 508, 1, 508, 1, 508, 1, 509, 1, 509, 1, 509, 1, 509, 1, + 509, 1, 509, 1, 509, 1, 509, 1, 510, 1, 510, 1, 510, 1, 510, 1, 510, 1, + 510, 1, 510, 1, 510, 1, 510, 1, 511, 1, 511, 1, 511, 1, 511, 1, 511, 1, + 512, 1, 512, 1, 512, 1, 512, 1, 512, 1, 512, 1, 512, 1, 513, 1, 513, 1, + 513, 1, 513, 1, 513, 1, 513, 1, 514, 1, 514, 1, 514, 1, 514, 1, 514, 1, + 514, 1, 515, 1, 515, 1, 515, 1, 515, 1, 515, 1, 515, 1, 515, 1, 515, 1, + 515, 1, 515, 1, 515, 1, 515, 1, 516, 1, 516, 1, 516, 1, 516, 1, 516, 1, + 517, 1, 517, 1, 517, 1, 517, 1, 517, 1, 517, 1, 518, 1, 518, 1, 518, 1, + 518, 1, 518, 1, 518, 1, 519, 1, 519, 1, 519, 1, 519, 1, 519, 1, 519, 1, + 520, 1, 520, 1, 520, 1, 520, 1, 520, 1, 521, 1, 521, 1, 521, 1, 522, 1, + 522, 1, 522, 1, 522, 1, 522, 1, 522, 1, 522, 1, 522, 1, 523, 1, 523, 1, + 523, 1, 523, 1, 523, 1, 523, 1, 523, 1, 524, 1, 524, 1, 524, 1, 524, 1, + 524, 1, 524, 1, 524, 1, 524, 1, 525, 1, 525, 1, 525, 1, 525, 1, 525, 1, + 525, 1, 525, 1, 525, 1, 525, 1, 525, 1, 525, 1, 526, 1, 526, 1, 526, 1, + 526, 1, 526, 1, 526, 1, 526, 1, 526, 1, 526, 1, 526, 1, 526, 1, 527, 1, + 527, 1, 527, 1, 527, 1, 527, 1, 527, 1, 527, 1, 528, 1, 528, 1, 528, 1, + 528, 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, 1, 529, 1, 529, 1, + 529, 1, 529, 1, 529, 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, 1, 531, 1, + 531, 1, 531, 1, 531, 1, 531, 1, 531, 1, 531, 1, 531, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 533, 1, 533, 1, 533, 1, 534, 1, + 534, 1, 534, 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 1, + 535, 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 1, 536, 1, 536, 1, 536, 1, + 536, 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, 1, 538, 1, + 538, 1, 538, 1, 538, 1, 538, 1, 539, 1, 539, 1, 539, 1, 539, 1, 539, 1, + 540, 1, 540, 1, 540, 1, 540, 1, 540, 1, 540, 1, 540, 1, 540, 1, 540, 1, + 540, 1, 540, 1, 540, 1, 540, 1, 540, 1, 540, 1, 540, 1, 541, 1, 541, 1, + 541, 1, 541, 1, 541, 1, 541, 1, 541, 1, 541, 1, 542, 1, 542, 1, 542, 1, + 542, 1, 542, 1, 542, 1, 543, 1, 543, 1, 543, 1, 543, 1, 543, 1, 543, 1, + 543, 1, 543, 1, 543, 1, 543, 1, 544, 1, 544, 1, 544, 1, 544, 1, 544, 1, + 545, 1, 545, 1, 545, 1, 545, 1, 545, 1, 545, 1, 545, 1, 545, 1, 545, 1, + 545, 1, 545, 1, 545, 1, 545, 1, 545, 1, 545, 1, 545, 1, 546, 1, 546, 1, + 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, + 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, + 546, 1, 546, 1, 546, 1, 547, 1, 547, 1, 547, 1, 547, 1, 547, 1, 547, 1, + 547, 1, 548, 1, 548, 1, 548, 1, 548, 1, 548, 1, 548, 1, 548, 1, 548, 1, + 549, 1, 549, 1, 549, 1, 549, 1, 549, 1, 549, 1, 549, 1, 549, 1, 549, 1, + 549, 1, 549, 1, 549, 1, 549, 1, 550, 1, 550, 1, 550, 1, 550, 1, 550, 1, + 550, 1, 550, 1, 550, 1, 550, 1, 550, 1, 550, 1, 551, 1, 551, 1, 551, 1, + 551, 1, 551, 1, 551, 1, 551, 1, 551, 1, 551, 1, 552, 1, 552, 1, 552, 1, + 552, 1, 552, 1, 552, 1, 552, 1, 552, 1, 552, 1, 552, 1, 552, 1, 552, 1, + 552, 1, 552, 1, 552, 1, 552, 1, 552, 1, 552, 1, 552, 1, 553, 1, 553, 1, + 553, 1, 553, 1, 553, 1, 553, 1, 554, 1, 554, 1, 554, 1, 554, 1, 554, 1, + 554, 1, 554, 1, 555, 1, 555, 1, 555, 1, 555, 1, 555, 1, 555, 1, 555, 1, + 555, 1, 555, 1, 555, 1, 555, 1, 556, 1, 556, 1, 556, 1, 556, 1, 556, 1, + 556, 1, 556, 1, 556, 1, 557, 1, 557, 1, 557, 1, 557, 1, 557, 1, 558, 1, + 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 559, 1, + 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, + 560, 1, 560, 1, 560, 1, 560, 1, 560, 1, 560, 1, 560, 1, 560, 1, 561, 1, + 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, 562, 1, + 562, 1, 562, 1, 562, 1, 562, 1, 563, 1, 563, 1, 563, 1, 563, 1, 563, 1, + 563, 1, 563, 1, 563, 1, 563, 1, 563, 1, 563, 1, 563, 1, 564, 1, 564, 1, + 564, 1, 564, 1, 564, 1, 564, 1, 564, 1, 564, 1, 565, 1, 565, 1, 565, 1, + 565, 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, 1, 566, 1, 566, 1, 566, 1, + 566, 1, 566, 1, 566, 1, 567, 1, 567, 1, 567, 1, 567, 1, 567, 1, 567, 1, + 568, 1, 568, 1, 568, 1, 568, 1, 568, 1, 568, 1, 569, 1, 569, 1, 569, 1, + 569, 1, 569, 1, 569, 1, 569, 1, 569, 1, 570, 1, 570, 1, 570, 1, 570, 1, + 570, 1, 570, 1, 570, 1, 570, 1, 571, 1, 571, 1, 571, 1, 571, 1, 571, 1, + 571, 1, 571, 1, 571, 1, 571, 1, 571, 1, 572, 1, 572, 1, 572, 1, 572, 1, + 572, 1, 572, 1, 572, 1, 572, 1, 572, 1, 572, 1, 572, 1, 572, 1, 572, 1, + 572, 1, 572, 1, 572, 1, 572, 1, 573, 1, 573, 1, 573, 1, 573, 1, 573, 1, + 573, 1, 573, 1, 573, 1, 573, 1, 573, 1, 574, 1, 574, 1, 574, 1, 574, 1, + 574, 1, 574, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, 1, + 575, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, 1, 576, 1, + 576, 1, 576, 1, 576, 1, 576, 1, 576, 1, 576, 1, 576, 1, 576, 1, 576, 1, + 576, 1, 576, 1, 576, 1, 576, 1, 577, 1, 577, 1, 577, 1, 577, 1, 577, 1, + 577, 1, 577, 1, 577, 1, 577, 1, 578, 1, 578, 1, 578, 1, 578, 1, 578, 1, + 578, 1, 578, 1, 579, 1, 579, 1, 579, 1, 579, 1, 579, 1, 579, 1, 579, 1, + 579, 1, 579, 1, 579, 1, 579, 1, 580, 1, 580, 1, 580, 1, 580, 1, 580, 1, + 580, 1, 580, 1, 581, 1, 581, 1, 581, 1, 581, 1, 581, 1, 581, 1, 581, 1, + 581, 1, 581, 1, 581, 1, 581, 1, 581, 1, 581, 1, 581, 1, 581, 1, 581, 1, + 582, 1, 582, 1, 582, 1, 582, 1, 582, 1, 582, 1, 582, 1, 582, 1, 582, 1, + 582, 1, 582, 1, 582, 1, 582, 1, 582, 1, 582, 1, 582, 1, 582, 1, 582, 1, + 582, 1, 583, 1, 583, 1, 583, 1, 583, 1, 583, 1, 583, 1, 583, 1, 583, 1, + 583, 1, 583, 1, 583, 1, 583, 1, 583, 1, 583, 1, 583, 1, 583, 1, 583, 1, + 583, 1, 583, 1, 583, 1, 584, 1, 584, 1, 584, 1, 584, 1, 584, 1, 584, 1, + 584, 1, 584, 1, 584, 1, 584, 1, 584, 1, 584, 1, 584, 1, 584, 1, 584, 1, + 584, 1, 584, 1, 584, 1, 584, 1, 584, 1, 584, 1, 584, 1, 584, 1, 585, 1, + 585, 1, 585, 1, 585, 1, 585, 1, 585, 1, 585, 1, 585, 1, 585, 1, 585, 1, + 585, 1, 585, 1, 585, 1, 585, 1, 585, 1, 585, 1, 585, 1, 585, 1, 585, 1, + 585, 1, 585, 1, 586, 1, 586, 1, 586, 1, 586, 1, 586, 1, 586, 1, 586, 1, + 586, 1, 586, 1, 586, 1, 586, 1, 586, 1, 586, 1, 586, 1, 586, 1, 586, 1, + 586, 1, 586, 1, 586, 1, 586, 1, 586, 1, 586, 1, 586, 1, 586, 1, 587, 1, + 587, 1, 587, 1, 587, 1, 587, 1, 587, 1, 587, 1, 587, 1, 587, 1, 587, 1, + 587, 1, 587, 1, 587, 1, 587, 1, 587, 1, 587, 1, 587, 1, 587, 1, 587, 1, + 587, 1, 587, 1, 587, 1, 587, 1, 587, 1, 587, 1, 587, 1, 587, 1, 587, 1, + 588, 1, 588, 1, 588, 1, 588, 1, 588, 1, 588, 1, 588, 1, 588, 1, 588, 1, + 588, 1, 588, 1, 588, 1, 589, 1, 589, 1, 589, 1, 589, 1, 589, 1, 589, 1, + 590, 1, 590, 1, 590, 1, 590, 1, 590, 1, 590, 1, 590, 1, 590, 1, 591, 1, + 591, 1, 591, 1, 591, 1, 591, 1, 591, 1, 591, 1, 592, 1, 592, 1, 592, 1, + 592, 1, 592, 1, 592, 1, 592, 1, 592, 1, 592, 1, 592, 1, 592, 1, 592, 1, + 592, 1, 592, 1, 592, 1, 592, 1, 592, 1, 592, 1, 593, 1, 593, 1, 593, 1, + 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 594, 1, 594, 1, + 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 595, 1, 595, 1, 595, 1, + 595, 1, 595, 1, 595, 1, 596, 1, 596, 1, 596, 1, 596, 1, 596, 1, 597, 1, + 597, 1, 597, 1, 597, 1, 597, 1, 597, 1, 597, 1, 597, 1, 597, 1, 598, 1, + 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 599, 1, 599, 1, 599, 1, + 599, 1, 599, 1, 599, 1, 599, 1, 600, 1, 600, 1, 600, 1, 600, 1, 601, 1, + 601, 1, 601, 1, 601, 1, 601, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, + 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 603, 1, 603, 1, 603, 1, + 603, 1, 603, 1, 603, 1, 604, 1, 604, 1, 604, 1, 604, 1, 604, 1, 604, 1, + 604, 1, 604, 1, 604, 1, 604, 1, 605, 1, 605, 1, 605, 1, 605, 1, 605, 1, + 605, 1, 605, 1, 605, 1, 605, 1, 606, 1, 606, 1, 606, 1, 606, 1, 606, 1, + 606, 1, 606, 1, 606, 1, 606, 1, 607, 1, 607, 1, 607, 1, 607, 1, 607, 1, + 607, 1, 607, 1, 607, 1, 607, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, + 608, 1, 608, 1, 609, 1, 609, 1, 609, 1, 609, 1, 609, 1, 609, 1, 609, 1, + 609, 1, 610, 1, 610, 1, 610, 1, 610, 1, 610, 1, 610, 1, 611, 1, 611, 1, + 611, 1, 611, 1, 611, 1, 611, 1, 611, 1, 612, 1, 612, 1, 612, 1, 612, 1, + 612, 1, 612, 1, 612, 1, 613, 1, 613, 1, 613, 1, 613, 1, 613, 1, 613, 1, + 613, 1, 614, 1, 614, 1, 614, 1, 614, 1, 614, 1, 614, 1, 615, 1, 615, 1, + 615, 1, 615, 1, 615, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, + 616, 1, 616, 1, 616, 1, 617, 1, 617, 1, 617, 1, 617, 1, 617, 1, 617, 1, + 617, 1, 618, 1, 618, 1, 618, 1, 618, 1, 618, 1, 619, 1, 619, 1, 619, 1, + 619, 1, 619, 1, 619, 1, 619, 1, 620, 1, 620, 1, 620, 1, 620, 1, 620, 1, + 620, 1, 620, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, + 622, 1, 622, 1, 622, 1, 622, 1, 622, 1, 622, 1, 622, 1, 622, 1, 622, 1, + 622, 1, 622, 1, 622, 1, 622, 1, 622, 1, 622, 1, 622, 1, 623, 1, 623, 1, + 623, 1, 623, 1, 623, 1, 623, 1, 623, 1, 623, 1, 623, 1, 623, 1, 623, 1, + 623, 1, 623, 1, 623, 1, 623, 1, 623, 1, 623, 1, 623, 1, 623, 1, 624, 1, + 624, 1, 624, 1, 624, 1, 624, 1, 624, 1, 624, 1, 624, 1, 624, 1, 624, 1, + 624, 1, 624, 1, 624, 1, 624, 1, 624, 1, 624, 1, 624, 1, 625, 1, 625, 1, + 625, 1, 625, 1, 625, 1, 625, 1, 625, 1, 625, 1, 625, 1, 625, 1, 625, 1, + 625, 1, 625, 1, 625, 1, 625, 1, 625, 1, 625, 1, 625, 1, 626, 1, 626, 1, + 626, 1, 626, 1, 626, 1, 626, 1, 626, 1, 626, 1, 626, 1, 626, 1, 627, 1, + 627, 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, 1, + 627, 1, 627, 1, 627, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, + 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 629, 1, 629, 1, 629, 1, 629, 1, + 629, 1, 629, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, + 631, 1, 631, 1, 631, 1, 631, 1, 631, 1, 631, 1, 631, 1, 631, 1, 631, 1, + 631, 1, 631, 1, 631, 1, 631, 1, 631, 1, 631, 1, 631, 1, 631, 1, 631, 1, + 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, + 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 633, 1, + 633, 1, 633, 1, 633, 1, 633, 1, 633, 1, 633, 1, 633, 1, 633, 1, 633, 1, + 633, 1, 633, 1, 633, 1, 633, 1, 633, 1, 633, 1, 633, 1, 633, 1, 633, 1, + 634, 1, 634, 1, 634, 1, 634, 1, 634, 1, 634, 1, 634, 1, 635, 1, 635, 1, + 635, 1, 635, 1, 635, 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, 1, + 636, 1, 636, 1, 637, 1, 637, 1, 637, 1, 637, 1, 637, 1, 637, 1, 637, 1, + 638, 1, 638, 1, 638, 1, 638, 1, 638, 1, 638, 1, 638, 1, 639, 1, 639, 1, + 639, 1, 639, 1, 639, 1, 639, 1, 639, 1, 639, 1, 639, 1, 639, 1, 639, 1, + 639, 1, 639, 1, 639, 1, 639, 1, 639, 1, 640, 1, 640, 1, 640, 1, 640, 1, + 640, 1, 640, 1, 640, 1, 640, 1, 641, 1, 641, 1, 641, 1, 641, 1, 641, 1, + 641, 1, 641, 1, 641, 1, 641, 1, 641, 1, 641, 1, 641, 1, 641, 1, 642, 1, + 642, 1, 642, 1, 642, 1, 642, 1, 642, 1, 642, 1, 642, 1, 642, 1, 642, 1, + 642, 1, 642, 1, 642, 1, 642, 1, 643, 1, 643, 1, 643, 1, 643, 1, 643, 1, + 643, 1, 643, 1, 643, 1, 644, 1, 644, 1, 644, 1, 644, 1, 644, 1, 644, 1, + 645, 1, 645, 1, 645, 1, 645, 1, 645, 1, 645, 1, 645, 1, 645, 1, 645, 1, + 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, + 646, 1, 646, 1, 647, 1, 647, 1, 647, 1, 647, 1, 647, 1, 647, 1, 647, 1, + 647, 1, 647, 1, 647, 1, 647, 1, 648, 1, 648, 1, 648, 1, 648, 1, 648, 1, + 648, 1, 648, 1, 648, 1, 648, 1, 648, 1, 648, 1, 649, 1, 649, 1, 649, 1, + 649, 1, 649, 1, 649, 1, 649, 1, 649, 1, 649, 1, 649, 1, 650, 1, 650, 1, + 650, 1, 650, 1, 650, 1, 650, 1, 650, 1, 650, 1, 650, 1, 650, 1, 651, 1, + 651, 1, 651, 1, 651, 1, 651, 1, 652, 1, 652, 1, 652, 1, 652, 1, 652, 1, + 652, 1, 652, 1, 652, 1, 652, 1, 652, 1, 652, 1, 652, 1, 653, 1, 653, 1, + 653, 1, 653, 1, 653, 1, 653, 1, 653, 1, 653, 1, 653, 1, 653, 1, 653, 1, + 653, 1, 654, 1, 654, 1, 654, 1, 654, 1, 654, 1, 654, 1, 654, 1, 654, 1, + 654, 1, 654, 1, 654, 1, 654, 1, 654, 1, 654, 1, 655, 1, 655, 1, 655, 1, + 655, 1, 655, 1, 655, 1, 655, 1, 655, 1, 655, 1, 656, 1, 656, 1, 656, 1, + 656, 1, 656, 1, 656, 1, 656, 1, 656, 1, 656, 1, 657, 1, 657, 1, 657, 1, + 657, 1, 657, 1, 657, 1, 657, 1, 657, 1, 657, 1, 657, 1, 658, 1, 658, 1, + 658, 1, 658, 1, 658, 1, 658, 1, 658, 1, 658, 1, 658, 1, 658, 1, 659, 1, + 659, 1, 659, 1, 659, 1, 659, 1, 659, 1, 659, 1, 659, 1, 659, 1, 660, 1, + 660, 1, 660, 1, 660, 1, 660, 1, 660, 1, 660, 1, 660, 1, 660, 1, 660, 1, + 660, 1, 660, 1, 660, 1, 660, 1, 660, 1, 660, 1, 660, 1, 661, 1, 661, 1, + 661, 1, 661, 1, 661, 1, 661, 1, 661, 1, 661, 1, 661, 1, 661, 1, 662, 1, + 662, 1, 662, 1, 662, 1, 662, 1, 662, 1, 662, 1, 662, 1, 663, 1, 663, 1, + 663, 1, 663, 1, 663, 1, 663, 1, 664, 1, 664, 1, 664, 1, 664, 1, 664, 1, + 664, 1, 664, 1, 664, 1, 665, 1, 665, 1, 665, 1, 665, 1, 665, 1, 666, 1, + 666, 1, 666, 1, 666, 1, 666, 1, 666, 1, 666, 1, 666, 1, 667, 1, 667, 1, + 667, 1, 667, 1, 667, 1, 667, 1, 667, 1, 667, 1, 667, 1, 667, 1, 667, 1, + 667, 1, 667, 1, 667, 1, 667, 1, 668, 1, 668, 1, 668, 1, 668, 1, 668, 1, + 668, 1, 668, 1, 668, 1, 668, 1, 668, 1, 668, 1, 669, 1, 669, 1, 669, 1, + 669, 1, 669, 1, 669, 1, 670, 1, 670, 1, 670, 1, 670, 1, 670, 1, 670, 1, + 670, 1, 670, 1, 670, 1, 670, 1, 671, 1, 671, 1, 671, 1, 671, 1, 671, 1, + 672, 1, 672, 1, 672, 1, 672, 1, 672, 1, 672, 1, 672, 1, 672, 1, 673, 1, + 673, 1, 673, 1, 673, 1, 673, 1, 673, 1, 673, 1, 673, 1, 674, 1, 674, 1, + 674, 1, 674, 1, 674, 1, 675, 1, 675, 1, 675, 1, 675, 1, 675, 1, 675, 1, + 675, 1, 675, 1, 675, 1, 676, 1, 676, 1, 676, 1, 676, 1, 676, 1, 676, 1, + 676, 1, 677, 1, 677, 1, 677, 1, 677, 1, 677, 1, 677, 1, 677, 1, 677, 1, + 678, 1, 678, 1, 678, 1, 678, 1, 678, 1, 679, 1, 679, 1, 679, 1, 679, 1, + 679, 1, 679, 1, 679, 1, 679, 1, 680, 1, 680, 1, 680, 1, 680, 1, 680, 1, + 681, 1, 681, 1, 681, 1, 682, 1, 682, 1, 682, 1, 682, 1, 683, 1, 683, 1, + 683, 1, 683, 1, 684, 1, 684, 1, 684, 1, 684, 1, 685, 1, 685, 1, 685, 1, + 685, 1, 686, 1, 686, 1, 686, 1, 686, 1, 687, 1, 687, 1, 687, 1, 687, 1, + 688, 1, 688, 1, 688, 1, 688, 1, 688, 1, 688, 1, 688, 1, 688, 1, 688, 1, + 689, 1, 689, 1, 689, 1, 689, 1, 689, 1, 689, 1, 689, 1, 689, 1, 690, 1, + 690, 1, 690, 1, 690, 1, 690, 1, 690, 1, 691, 1, 691, 1, 691, 1, 691, 1, + 692, 1, 692, 1, 692, 1, 692, 1, 692, 1, 693, 1, 693, 1, 693, 1, 693, 1, + 693, 1, 693, 1, 693, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 695, 1, + 695, 1, 695, 1, 695, 1, 695, 1, 695, 1, 695, 1, 696, 1, 696, 1, 696, 1, + 696, 1, 696, 1, 696, 1, 696, 1, 696, 1, 696, 1, 696, 1, 696, 1, 696, 1, + 697, 1, 697, 1, 697, 1, 697, 1, 697, 1, 697, 1, 698, 1, 698, 1, 698, 1, + 698, 1, 698, 1, 698, 1, 698, 1, 698, 1, 698, 1, 698, 1, 698, 1, 698, 1, + 698, 1, 698, 1, 698, 1, 698, 1, 698, 1, 698, 1, 698, 1, 698, 1, 698, 1, + 698, 1, 698, 1, 698, 1, 698, 1, 698, 1, 698, 1, 699, 1, 699, 1, 699, 1, + 699, 1, 699, 1, 699, 1, 699, 1, 699, 1, 699, 1, 699, 1, 699, 1, 699, 1, + 699, 1, 699, 1, 699, 1, 699, 1, 699, 1, 699, 1, 699, 1, 700, 1, 700, 1, + 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, + 700, 1, 701, 1, 701, 1, 701, 1, 701, 1, 701, 1, 701, 1, 701, 1, 701, 1, + 701, 1, 701, 1, 701, 1, 701, 1, 701, 1, 701, 1, 701, 1, 701, 1, 701, 1, + 701, 1, 701, 1, 701, 1, 701, 1, 701, 1, 701, 1, 701, 1, 701, 1, 701, 1, + 701, 1, 701, 1, 702, 1, 702, 1, 702, 1, 702, 1, 702, 1, 702, 1, 702, 1, + 702, 1, 702, 1, 702, 1, 702, 1, 702, 1, 702, 1, 703, 1, 703, 1, 703, 1, + 703, 1, 703, 1, 703, 1, 703, 1, 703, 1, 703, 1, 703, 1, 703, 1, 703, 1, + 703, 1, 704, 1, 704, 1, 704, 1, 704, 1, 704, 1, 704, 1, 704, 1, 704, 1, + 704, 1, 704, 1, 704, 1, 704, 1, 704, 1, 704, 1, 704, 1, 704, 1, 704, 1, + 704, 1, 704, 1, 704, 1, 704, 1, 704, 1, 704, 1, 704, 1, 705, 1, 705, 1, + 705, 1, 705, 1, 705, 1, 705, 1, 705, 1, 705, 1, 705, 1, 705, 1, 705, 1, + 705, 1, 706, 1, 706, 1, 706, 1, 706, 1, 706, 1, 706, 1, 706, 1, 706, 1, + 706, 1, 706, 1, 706, 1, 706, 1, 706, 1, 706, 1, 706, 1, 706, 1, 706, 1, + 707, 1, 707, 1, 707, 1, 707, 1, 707, 1, 707, 1, 707, 1, 707, 1, 707, 1, + 707, 1, 707, 1, 707, 1, 707, 1, 707, 1, 707, 1, 707, 1, 707, 1, 707, 1, + 707, 1, 707, 1, 707, 1, 708, 1, 708, 1, 708, 1, 708, 1, 708, 1, 708, 1, + 708, 1, 708, 1, 709, 1, 709, 1, 709, 1, 709, 1, 709, 1, 710, 1, 710, 1, + 710, 1, 710, 1, 710, 1, 710, 1, 710, 1, 710, 1, 710, 1, 710, 1, 710, 1, + 710, 1, 710, 1, 710, 1, 710, 1, 711, 1, 711, 1, 711, 1, 711, 1, 711, 1, + 711, 1, 711, 1, 711, 1, 711, 1, 711, 1, 711, 1, 711, 1, 711, 1, 711, 1, + 711, 1, 711, 1, 712, 1, 712, 1, 712, 1, 712, 1, 712, 1, 712, 1, 712, 1, + 712, 1, 712, 1, 712, 1, 712, 1, 712, 1, 712, 1, 712, 1, 713, 1, 713, 1, + 713, 1, 713, 1, 713, 1, 713, 1, 713, 1, 713, 1, 713, 1, 713, 1, 713, 1, + 713, 1, 713, 1, 713, 1, 713, 1, 713, 1, 713, 1, 713, 1, 713, 1, 713, 1, + 713, 1, 713, 1, 714, 1, 714, 1, 714, 1, 714, 1, 714, 1, 714, 1, 714, 1, + 714, 1, 714, 1, 714, 1, 714, 1, 714, 1, 714, 1, 715, 1, 715, 1, 715, 1, + 715, 1, 715, 1, 715, 1, 715, 1, 715, 1, 715, 1, 715, 1, 715, 1, 715, 1, + 715, 1, 716, 1, 716, 1, 716, 1, 716, 1, 716, 1, 716, 1, 716, 1, 716, 1, + 716, 1, 716, 1, 716, 1, 716, 1, 716, 1, 716, 1, 716, 1, 716, 1, 716, 1, + 716, 1, 716, 1, 716, 1, 716, 1, 717, 1, 717, 1, 717, 1, 717, 1, 717, 1, + 717, 1, 717, 1, 717, 1, 717, 1, 717, 1, 717, 1, 717, 1, 717, 1, 717, 1, + 717, 1, 717, 1, 717, 1, 717, 1, 717, 1, 717, 1, 717, 1, 717, 1, 717, 1, + 717, 1, 718, 1, 718, 1, 718, 1, 718, 1, 718, 1, 718, 1, 718, 1, 718, 1, + 718, 1, 718, 1, 718, 1, 718, 1, 718, 1, 718, 1, 718, 1, 718, 1, 718, 1, + 718, 1, 718, 1, 718, 1, 718, 1, 718, 1, 718, 1, 718, 1, 719, 1, 719, 1, + 719, 1, 719, 1, 719, 1, 719, 1, 719, 1, 719, 1, 719, 1, 719, 1, 719, 1, + 719, 1, 719, 1, 719, 1, 719, 1, 719, 1, 719, 1, 719, 1, 719, 1, 719, 1, + 719, 1, 719, 1, 719, 1, 720, 1, 720, 1, 720, 1, 720, 1, 720, 1, 720, 1, + 720, 1, 721, 1, 721, 1, 721, 1, 721, 1, 721, 1, 721, 1, 721, 1, 722, 1, + 722, 1, 722, 1, 722, 1, 722, 1, 722, 1, 722, 1, 722, 1, 722, 1, 722, 1, + 722, 1, 722, 1, 722, 1, 722, 1, 722, 1, 722, 1, 723, 1, 723, 1, 723, 1, + 723, 1, 723, 1, 723, 1, 723, 1, 723, 1, 723, 1, 723, 1, 723, 1, 723, 1, + 723, 1, 723, 1, 723, 1, 723, 1, 723, 1, 723, 1, 723, 1, 723, 1, 723, 1, + 723, 1, 723, 1, 723, 1, 724, 1, 724, 1, 724, 1, 724, 1, 724, 1, 724, 1, + 724, 1, 724, 1, 724, 1, 724, 1, 724, 1, 724, 1, 724, 1, 724, 1, 724, 1, + 724, 1, 724, 1, 724, 1, 724, 1, 724, 1, 724, 1, 724, 1, 724, 1, 724, 1, + 724, 1, 724, 1, 724, 1, 725, 1, 725, 1, 725, 1, 725, 1, 725, 1, 725, 1, + 725, 1, 725, 1, 725, 1, 725, 1, 725, 1, 726, 1, 726, 1, 726, 1, 726, 1, + 726, 1, 726, 1, 726, 1, 726, 1, 727, 1, 727, 1, 727, 1, 727, 1, 727, 1, + 727, 1, 727, 1, 728, 1, 728, 1, 728, 1, 728, 1, 728, 1, 728, 1, 728, 1, + 728, 1, 728, 1, 728, 1, 728, 1, 728, 1, 728, 1, 728, 1, 728, 1, 728, 1, + 728, 1, 728, 1, 728, 1, 728, 1, 729, 1, 729, 1, 729, 1, 729, 1, 729, 1, + 729, 1, 729, 1, 729, 1, 729, 1, 729, 1, 729, 1, 729, 1, 729, 1, 729, 1, + 729, 1, 729, 1, 729, 1, 729, 1, 729, 1, 729, 1, 729, 1, 729, 1, 729, 1, + 729, 1, 730, 1, 730, 1, 730, 1, 730, 1, 730, 1, 730, 1, 730, 1, 730, 1, + 730, 1, 730, 1, 730, 1, 730, 1, 730, 1, 730, 1, 730, 1, 730, 1, 730, 1, + 730, 1, 730, 1, 730, 1, 730, 1, 731, 1, 731, 1, 731, 1, 731, 1, 731, 1, + 731, 1, 731, 1, 731, 1, 731, 1, 731, 1, 731, 1, 731, 1, 731, 1, 731, 1, + 731, 1, 731, 1, 731, 1, 731, 1, 731, 1, 731, 1, 732, 1, 732, 1, 732, 1, + 732, 1, 732, 1, 732, 1, 732, 1, 732, 1, 732, 1, 732, 1, 732, 1, 733, 1, + 733, 1, 733, 1, 733, 1, 733, 1, 733, 1, 733, 1, 733, 1, 734, 1, 734, 1, + 734, 1, 735, 1, 735, 1, 735, 1, 735, 1, 735, 1, 735, 1, 735, 1, 735, 1, + 735, 1, 735, 1, 735, 1, 735, 1, 735, 1, 735, 1, 735, 1, 735, 1, 735, 1, + 735, 1, 735, 1, 735, 1, 735, 1, 735, 1, 735, 1, 735, 1, 735, 1, 736, 3, + 736, 9279, 8, 736, 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, + 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, + 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, + 3, 736, 9306, 8, 736, 1, 737, 1, 737, 1, 737, 1, 737, 1, 737, 1, 737, 1, + 737, 1, 737, 1, 737, 1, 737, 1, 737, 1, 737, 1, 738, 1, 738, 1, 738, 1, + 738, 1, 738, 1, 738, 1, 738, 1, 738, 1, 738, 1, 738, 1, 738, 1, 738, 1, + 738, 1, 739, 1, 739, 1, 739, 1, 739, 1, 739, 1, 739, 1, 739, 1, 739, 1, + 739, 1, 740, 1, 740, 1, 740, 1, 740, 1, 740, 1, 740, 1, 741, 1, 741, 1, + 741, 1, 741, 1, 741, 1, 741, 1, 741, 1, 741, 1, 741, 1, 741, 1, 741, 1, + 741, 1, 741, 1, 741, 1, 741, 1, 741, 1, 741, 1, 741, 1, 741, 1, 741, 1, + 741, 1, 741, 1, 741, 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, 1, + 742, 1, 743, 1, 743, 1, 743, 1, 743, 1, 743, 1, 743, 1, 743, 1, 743, 1, + 743, 1, 743, 1, 743, 1, 743, 1, 743, 1, 743, 1, 743, 1, 743, 1, 743, 1, + 743, 1, 743, 1, 743, 1, 743, 1, 743, 1, 743, 1, 744, 1, 744, 1, 744, 1, + 744, 1, 744, 1, 744, 1, 744, 1, 744, 1, 744, 1, 744, 1, 744, 1, 744, 1, + 744, 1, 744, 1, 744, 1, 744, 1, 744, 1, 744, 1, 744, 1, 744, 1, 745, 1, + 745, 1, 745, 1, 745, 1, 745, 1, 745, 1, 745, 1, 745, 1, 745, 1, 745, 1, + 745, 1, 745, 1, 745, 1, 745, 1, 745, 1, 745, 1, 745, 1, 746, 1, 746, 1, + 746, 1, 746, 1, 746, 1, 746, 1, 746, 1, 746, 1, 746, 1, 747, 1, 747, 1, + 747, 1, 747, 1, 747, 1, 747, 1, 748, 1, 748, 1, 748, 1, 748, 1, 748, 1, + 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 750, 1, 750, 1, + 750, 1, 750, 1, 750, 1, 750, 1, 750, 1, 751, 1, 751, 1, 751, 1, 751, 1, + 751, 1, 751, 1, 751, 1, 752, 1, 752, 1, 752, 1, 752, 1, 752, 1, 752, 1, + 752, 1, 753, 1, 753, 1, 753, 1, 753, 1, 753, 1, 753, 1, 754, 1, 754, 1, + 754, 1, 754, 1, 754, 1, 754, 1, 755, 1, 755, 1, 755, 1, 755, 1, 755, 1, + 755, 1, 756, 1, 756, 1, 756, 1, 756, 1, 756, 1, 756, 1, 757, 1, 757, 1, + 757, 1, 757, 1, 757, 1, 758, 1, 758, 1, 758, 1, 758, 1, 758, 1, 758, 1, + 758, 1, 758, 1, 759, 1, 759, 1, 759, 1, 759, 1, 759, 1, 759, 1, 760, 1, + 760, 1, 760, 1, 760, 1, 760, 1, 760, 1, 760, 1, 760, 1, 761, 1, 761, 1, + 761, 1, 761, 1, 761, 1, 761, 1, 761, 1, 762, 1, 762, 1, 762, 1, 762, 1, + 763, 1, 763, 1, 763, 1, 763, 1, 763, 1, 763, 1, 763, 1, 763, 1, 764, 1, + 764, 1, 764, 1, 764, 1, 764, 1, 764, 1, 765, 1, 765, 1, 765, 1, 765, 1, + 765, 1, 765, 1, 765, 1, 766, 1, 766, 1, 766, 1, 766, 1, 767, 1, 767, 1, + 767, 1, 767, 1, 767, 1, 767, 1, 767, 1, 767, 1, 768, 1, 768, 1, 768, 1, + 768, 1, 768, 1, 768, 1, 769, 1, 769, 1, 769, 1, 769, 1, 769, 1, 769, 1, + 770, 1, 770, 1, 770, 1, 770, 1, 770, 1, 770, 1, 770, 1, 771, 1, 771, 1, + 771, 1, 771, 1, 771, 1, 771, 1, 771, 1, 772, 1, 772, 1, 772, 1, 772, 1, + 772, 1, 772, 1, 772, 1, 773, 1, 773, 1, 773, 1, 773, 1, 773, 1, 773, 1, + 773, 1, 774, 1, 774, 1, 774, 1, 774, 1, 774, 1, 774, 1, 775, 1, 775, 1, + 775, 1, 775, 1, 775, 1, 775, 1, 775, 1, 775, 1, 775, 1, 776, 1, 776, 1, + 776, 1, 776, 1, 776, 1, 777, 1, 777, 1, 777, 1, 777, 1, 777, 1, 778, 1, + 778, 1, 778, 1, 778, 1, 778, 1, 778, 1, 778, 1, 779, 1, 779, 1, 779, 1, + 779, 1, 779, 1, 780, 1, 780, 1, 780, 1, 780, 1, 780, 1, 781, 1, 781, 1, + 781, 1, 781, 1, 781, 1, 781, 1, 782, 1, 782, 1, 782, 1, 782, 1, 782, 1, + 782, 1, 782, 1, 782, 1, 783, 1, 783, 1, 783, 1, 783, 1, 783, 1, 783, 1, + 784, 1, 784, 1, 784, 1, 784, 1, 784, 1, 785, 1, 785, 1, 785, 1, 785, 1, + 785, 1, 785, 1, 785, 1, 785, 1, 786, 1, 786, 1, 786, 1, 786, 1, 786, 1, + 786, 1, 786, 1, 786, 1, 787, 1, 787, 1, 787, 1, 787, 1, 787, 1, 787, 1, + 787, 1, 787, 1, 788, 1, 788, 1, 788, 1, 788, 1, 788, 1, 788, 1, 788, 1, + 788, 1, 788, 1, 788, 1, 789, 1, 789, 1, 789, 1, 789, 1, 790, 1, 790, 1, + 790, 1, 790, 1, 790, 1, 790, 1, 790, 1, 790, 1, 790, 1, 790, 1, 791, 1, + 791, 1, 791, 1, 791, 1, 791, 1, 791, 1, 791, 1, 792, 1, 792, 1, 792, 1, + 792, 1, 792, 1, 792, 1, 792, 1, 793, 1, 793, 1, 793, 1, 793, 1, 793, 1, + 793, 1, 793, 1, 793, 1, 793, 1, 793, 1, 793, 1, 794, 1, 794, 1, 794, 1, + 794, 1, 794, 1, 794, 1, 794, 1, 795, 1, 795, 1, 795, 1, 795, 1, 796, 1, + 796, 1, 796, 1, 796, 1, 796, 1, 796, 1, 796, 1, 796, 1, 796, 1, 796, 1, + 796, 1, 797, 1, 797, 1, 797, 1, 797, 1, 797, 1, 797, 1, 797, 1, 797, 1, + 797, 1, 797, 1, 797, 1, 797, 1, 797, 1, 797, 1, 797, 1, 797, 1, 797, 1, + 797, 1, 797, 1, 798, 1, 798, 1, 798, 1, 798, 1, 798, 1, 798, 1, 798, 1, + 799, 1, 799, 1, 799, 1, 799, 1, 799, 1, 799, 1, 799, 1, 799, 1, 799, 1, + 799, 1, 799, 1, 800, 1, 800, 1, 800, 1, 800, 1, 800, 1, 800, 1, 800, 1, + 800, 1, 800, 1, 800, 1, 801, 1, 801, 1, 801, 1, 801, 1, 801, 1, 801, 1, + 801, 1, 801, 1, 801, 1, 801, 1, 801, 1, 801, 1, 802, 1, 802, 1, 802, 1, + 802, 1, 802, 1, 802, 1, 802, 1, 802, 1, 802, 1, 802, 1, 802, 1, 802, 1, + 802, 1, 803, 1, 803, 1, 803, 1, 803, 1, 803, 1, 803, 1, 803, 1, 803, 1, + 803, 1, 803, 1, 803, 1, 803, 1, 803, 1, 803, 1, 803, 1, 803, 1, 803, 1, + 803, 1, 803, 1, 804, 1, 804, 1, 804, 1, 804, 1, 804, 1, 804, 1, 804, 1, + 804, 1, 804, 1, 804, 1, 804, 1, 804, 1, 804, 1, 804, 1, 804, 1, 805, 1, + 805, 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, 1, 806, 1, + 806, 1, 806, 1, 806, 1, 806, 1, 806, 1, 806, 1, 806, 1, 806, 1, 806, 1, + 806, 1, 807, 1, 807, 1, 807, 1, 807, 1, 807, 1, 807, 1, 807, 1, 807, 1, + 807, 1, 807, 1, 807, 1, 807, 1, 807, 1, 807, 1, 807, 1, 807, 1, 808, 1, + 808, 1, 808, 1, 808, 1, 808, 1, 808, 1, 808, 1, 808, 1, 808, 1, 808, 1, + 808, 1, 809, 1, 809, 1, 809, 1, 809, 1, 809, 1, 809, 1, 809, 1, 809, 1, + 809, 1, 809, 1, 809, 1, 809, 1, 809, 1, 810, 1, 810, 1, 810, 1, 810, 1, + 810, 1, 810, 1, 811, 1, 811, 1, 811, 1, 811, 1, 811, 1, 811, 1, 811, 1, + 811, 1, 812, 1, 812, 1, 812, 1, 812, 1, 813, 1, 813, 1, 813, 1, 813, 1, + 813, 1, 814, 1, 814, 1, 814, 1, 814, 1, 814, 1, 814, 1, 814, 1, 814, 1, + 815, 1, 815, 1, 815, 1, 815, 1, 815, 1, 815, 1, 815, 1, 815, 1, 816, 1, + 816, 1, 816, 1, 816, 1, 816, 1, 816, 1, 816, 1, 816, 1, 816, 1, 816, 1, + 816, 1, 816, 1, 817, 1, 817, 1, 817, 1, 817, 1, 817, 1, 817, 1, 817, 1, + 817, 1, 817, 1, 817, 1, 817, 1, 817, 1, 818, 1, 818, 1, 818, 1, 818, 1, + 818, 1, 819, 1, 819, 1, 819, 1, 819, 1, 819, 1, 819, 1, 819, 1, 819, 1, + 819, 1, 820, 1, 820, 1, 820, 1, 820, 1, 820, 1, 821, 1, 821, 1, 821, 1, + 821, 1, 821, 1, 821, 1, 821, 1, 822, 1, 822, 1, 822, 1, 822, 1, 822, 1, + 822, 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, 1, 824, 1, 824, 1, + 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, + 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 825, 1, + 825, 1, 825, 1, 825, 1, 825, 1, 825, 1, 825, 1, 825, 1, 825, 1, 825, 1, + 825, 1, 825, 1, 825, 1, 825, 1, 825, 1, 825, 1, 825, 1, 825, 1, 826, 1, + 826, 1, 826, 1, 826, 1, 826, 1, 826, 1, 826, 1, 826, 1, 826, 1, 826, 1, + 826, 1, 826, 1, 826, 1, 826, 1, 826, 1, 826, 1, 826, 1, 826, 1, 826, 1, + 827, 1, 827, 1, 827, 1, 827, 1, 827, 1, 827, 1, 827, 1, 827, 1, 827, 1, + 827, 1, 827, 1, 827, 1, 827, 1, 827, 1, 827, 1, 827, 1, 828, 1, 828, 1, + 828, 1, 828, 1, 828, 1, 828, 1, 828, 1, 828, 1, 828, 1, 828, 1, 828, 1, + 828, 1, 828, 1, 828, 1, 828, 1, 828, 1, 828, 1, 828, 1, 829, 1, 829, 1, + 829, 1, 829, 1, 829, 1, 830, 1, 830, 1, 830, 1, 830, 1, 830, 1, 830, 1, + 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, + 831, 1, 832, 1, 832, 1, 832, 1, 832, 1, 833, 1, 833, 1, 833, 1, 833, 1, + 833, 1, 833, 1, 833, 1, 833, 1, 833, 1, 833, 1, 834, 1, 834, 1, 834, 1, + 834, 1, 834, 1, 834, 1, 834, 1, 834, 1, 834, 1, 834, 1, 834, 1, 835, 1, + 835, 1, 835, 1, 835, 1, 835, 1, 835, 1, 835, 1, 836, 1, 836, 1, 836, 1, + 836, 1, 836, 1, 836, 1, 836, 1, 836, 1, 836, 1, 836, 1, 836, 1, 836, 1, + 836, 1, 837, 1, 837, 1, 837, 1, 837, 1, 837, 1, 838, 1, 838, 1, 838, 1, + 838, 1, 838, 1, 838, 1, 838, 1, 838, 1, 839, 1, 839, 1, 839, 1, 839, 1, + 839, 1, 839, 1, 839, 1, 839, 1, 839, 1, 840, 1, 840, 1, 840, 1, 840, 1, + 840, 1, 840, 1, 840, 1, 840, 1, 840, 1, 840, 1, 840, 1, 840, 1, 840, 1, + 840, 1, 840, 1, 840, 1, 840, 1, 841, 1, 841, 1, 841, 1, 841, 1, 841, 1, + 841, 1, 841, 1, 841, 1, 842, 1, 842, 1, 842, 1, 842, 1, 842, 1, 842, 1, + 842, 1, 842, 1, 842, 1, 842, 1, 842, 1, 842, 1, 843, 1, 843, 1, 843, 1, + 843, 1, 843, 1, 843, 1, 843, 1, 843, 1, 843, 1, 843, 1, 843, 1, 843, 1, + 843, 1, 844, 1, 844, 1, 844, 1, 844, 1, 844, 1, 844, 1, 844, 1, 844, 1, + 844, 1, 844, 1, 845, 1, 845, 1, 845, 1, 845, 1, 845, 1, 845, 1, 845, 1, + 845, 1, 845, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 1, + 847, 1, 847, 1, 847, 1, 847, 1, 847, 1, 847, 1, 847, 1, 847, 1, 847, 1, + 847, 1, 848, 1, 848, 1, 848, 1, 848, 1, 848, 1, 848, 1, 848, 1, 848, 1, + 848, 1, 848, 1, 848, 1, 848, 1, 848, 1, 848, 1, 849, 1, 849, 1, 849, 1, + 849, 1, 849, 1, 850, 1, 850, 1, 850, 1, 850, 1, 850, 1, 850, 1, 850, 1, + 850, 1, 850, 1, 850, 1, 850, 1, 851, 1, 851, 1, 851, 1, 851, 1, 852, 1, + 852, 1, 852, 1, 852, 1, 853, 1, 853, 1, 853, 1, 853, 1, 853, 1, 853, 1, + 854, 1, 854, 1, 854, 1, 854, 1, 854, 1, 854, 1, 854, 1, 854, 1, 854, 1, + 854, 1, 854, 1, 854, 1, 854, 1, 854, 1, 854, 1, 854, 1, 854, 1, 854, 1, + 854, 1, 854, 1, 854, 1, 854, 1, 854, 1, 854, 1, 854, 1, 854, 1, 854, 1, + 855, 1, 855, 1, 855, 1, 855, 1, 855, 1, 855, 1, 855, 1, 855, 1, 855, 1, + 855, 1, 855, 1, 855, 1, 855, 1, 855, 1, 855, 1, 855, 1, 855, 1, 855, 1, + 855, 1, 855, 1, 855, 1, 855, 1, 855, 1, 855, 1, 855, 1, 855, 1, 856, 1, + 856, 1, 856, 1, 856, 1, 856, 1, 856, 1, 856, 1, 856, 1, 856, 1, 856, 1, + 856, 1, 856, 1, 856, 1, 856, 1, 856, 1, 856, 1, 856, 1, 856, 1, 856, 1, + 856, 1, 856, 1, 857, 1, 857, 1, 857, 1, 857, 1, 857, 1, 857, 1, 857, 1, + 857, 1, 857, 1, 857, 1, 857, 1, 857, 1, 857, 1, 857, 1, 858, 1, 858, 1, + 858, 1, 858, 1, 858, 1, 858, 1, 858, 1, 858, 1, 859, 1, 859, 1, 859, 1, + 859, 1, 859, 1, 859, 1, 859, 1, 859, 1, 859, 1, 860, 1, 860, 1, 860, 1, + 860, 1, 860, 1, 860, 1, 860, 1, 860, 1, 860, 1, 860, 1, 860, 1, 860, 1, + 861, 1, 861, 1, 861, 1, 861, 1, 861, 1, 861, 1, 861, 1, 861, 1, 862, 1, + 862, 1, 862, 1, 862, 1, 862, 1, 862, 1, 862, 1, 862, 1, 862, 1, 862, 1, + 862, 1, 863, 1, 863, 1, 863, 1, 863, 1, 863, 1, 863, 1, 863, 1, 863, 1, + 863, 1, 863, 1, 864, 1, 864, 1, 864, 1, 864, 1, 864, 1, 864, 1, 864, 1, + 864, 1, 864, 1, 864, 1, 865, 1, 865, 1, 865, 1, 865, 1, 865, 1, 865, 1, + 865, 1, 866, 1, 866, 1, 866, 1, 866, 1, 866, 1, 866, 1, 866, 1, 866, 1, + 867, 1, 867, 1, 867, 1, 867, 1, 867, 1, 867, 1, 867, 1, 867, 1, 867, 1, + 867, 1, 867, 1, 867, 1, 868, 1, 868, 1, 868, 1, 868, 1, 868, 1, 868, 1, + 868, 1, 868, 1, 868, 1, 868, 1, 868, 1, 868, 1, 869, 1, 869, 1, 869, 1, + 869, 1, 869, 1, 869, 1, 869, 1, 869, 1, 869, 1, 869, 1, 870, 1, 870, 1, + 870, 1, 870, 1, 870, 1, 870, 1, 870, 1, 870, 1, 870, 1, 871, 1, 871, 1, + 871, 1, 871, 1, 871, 1, 871, 1, 871, 1, 871, 1, 871, 1, 872, 1, 872, 1, + 872, 1, 872, 1, 873, 1, 873, 1, 873, 1, 873, 1, 873, 1, 873, 1, 873, 1, + 874, 1, 874, 1, 874, 1, 874, 1, 874, 1, 874, 1, 874, 1, 874, 1, 875, 1, + 875, 1, 875, 1, 875, 1, 875, 1, 875, 1, 875, 1, 875, 1, 875, 1, 876, 1, + 876, 1, 876, 1, 876, 1, 876, 1, 876, 1, 876, 1, 876, 1, 876, 1, 876, 1, + 876, 1, 876, 1, 876, 1, 876, 1, 876, 1, 876, 1, 876, 1, 877, 1, 877, 1, + 877, 1, 877, 1, 877, 1, 877, 1, 877, 1, 877, 1, 877, 1, 878, 1, 878, 1, + 878, 1, 878, 1, 878, 1, 878, 1, 878, 1, 879, 1, 879, 1, 879, 1, 879, 1, + 880, 1, 880, 1, 880, 1, 880, 1, 880, 1, 880, 1, 880, 1, 880, 1, 880, 1, + 880, 1, 880, 1, 881, 1, 881, 1, 881, 1, 881, 1, 881, 1, 881, 1, 881, 1, + 881, 1, 881, 1, 881, 1, 881, 1, 881, 1, 881, 1, 882, 1, 882, 1, 882, 1, + 882, 1, 882, 1, 882, 1, 882, 1, 882, 1, 882, 1, 882, 1, 882, 1, 882, 1, + 882, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 884, 1, 884, 1, + 884, 1, 884, 1, 884, 1, 884, 1, 884, 1, 884, 1, 884, 1, 884, 1, 884, 1, + 884, 1, 885, 1, 885, 1, 885, 1, 885, 1, 885, 1, 885, 1, 886, 1, 886, 1, + 886, 1, 886, 1, 886, 1, 886, 1, 886, 1, 887, 1, 887, 1, 887, 1, 887, 1, + 887, 1, 887, 1, 887, 1, 887, 1, 887, 1, 887, 1, 887, 1, 888, 1, 888, 1, + 888, 1, 888, 1, 888, 1, 888, 1, 888, 1, 888, 1, 888, 1, 888, 1, 888, 1, + 888, 1, 889, 1, 889, 1, 889, 1, 889, 1, 889, 1, 889, 1, 889, 1, 889, 1, + 889, 1, 889, 1, 890, 1, 890, 1, 890, 1, 890, 1, 890, 1, 890, 1, 890, 1, + 890, 1, 890, 1, 890, 1, 890, 1, 890, 1, 890, 1, 890, 1, 891, 1, 891, 1, + 891, 1, 891, 1, 891, 1, 891, 1, 891, 1, 891, 1, 891, 1, 891, 1, 891, 1, + 891, 1, 891, 1, 891, 1, 891, 1, 891, 1, 891, 1, 892, 1, 892, 1, 892, 1, + 892, 1, 892, 1, 892, 1, 892, 1, 892, 1, 892, 1, 892, 1, 892, 1, 892, 1, + 892, 1, 892, 1, 892, 1, 892, 1, 893, 1, 893, 1, 893, 1, 893, 1, 893, 1, + 893, 1, 893, 1, 893, 1, 893, 1, 893, 1, 893, 1, 893, 1, 893, 1, 893, 1, + 893, 1, 893, 1, 893, 1, 893, 1, 893, 1, 893, 1, 893, 1, 893, 1, 893, 1, + 893, 1, 893, 1, 893, 1, 893, 1, 894, 1, 894, 1, 894, 1, 894, 1, 894, 1, + 894, 1, 894, 1, 894, 1, 894, 1, 894, 1, 894, 1, 894, 1, 894, 1, 894, 1, + 894, 1, 894, 1, 894, 1, 894, 1, 894, 1, 894, 1, 894, 1, 894, 1, 894, 1, + 894, 1, 894, 1, 894, 1, 895, 1, 895, 1, 895, 1, 895, 1, 895, 1, 895, 1, + 895, 1, 895, 1, 895, 1, 895, 1, 895, 1, 895, 1, 895, 1, 895, 1, 895, 1, + 895, 1, 895, 1, 896, 1, 896, 1, 896, 1, 896, 1, 896, 1, 896, 1, 896, 1, + 896, 1, 896, 1, 896, 1, 896, 1, 896, 1, 896, 1, 896, 1, 896, 1, 896, 1, + 897, 1, 897, 1, 897, 1, 897, 1, 897, 1, 897, 1, 897, 1, 897, 1, 897, 1, + 897, 1, 898, 1, 898, 1, 898, 1, 898, 1, 898, 1, 898, 1, 898, 1, 898, 1, + 898, 1, 898, 1, 898, 1, 898, 1, 898, 1, 899, 1, 899, 1, 899, 1, 899, 1, + 899, 1, 899, 1, 899, 1, 899, 1, 899, 1, 899, 1, 899, 1, 899, 1, 899, 1, + 900, 1, 900, 1, 900, 1, 900, 1, 900, 1, 900, 1, 900, 1, 900, 1, 900, 1, + 900, 1, 900, 1, 900, 1, 901, 1, 901, 1, 901, 1, 901, 1, 901, 1, 901, 1, + 901, 1, 901, 1, 901, 1, 901, 1, 901, 1, 902, 1, 902, 1, 902, 1, 902, 1, + 902, 1, 902, 1, 902, 1, 902, 1, 902, 1, 903, 1, 903, 1, 903, 1, 903, 1, + 903, 1, 903, 1, 903, 1, 903, 1, 904, 1, 904, 1, 904, 1, 904, 1, 904, 1, + 904, 1, 904, 1, 904, 1, 904, 1, 905, 1, 905, 1, 905, 1, 905, 1, 905, 1, + 905, 1, 905, 1, 905, 1, 905, 1, 905, 1, 905, 1, 905, 1, 906, 1, 906, 1, + 906, 1, 906, 1, 906, 1, 906, 1, 906, 1, 906, 1, 906, 1, 906, 1, 906, 1, + 906, 1, 906, 1, 906, 1, 907, 1, 907, 1, 907, 1, 907, 1, 908, 1, 908, 1, + 908, 1, 908, 1, 908, 1, 908, 1, 908, 1, 909, 1, 909, 1, 909, 1, 909, 1, + 909, 1, 909, 1, 909, 1, 909, 1, 909, 1, 909, 1, 909, 1, 910, 1, 910, 1, + 910, 1, 910, 1, 910, 1, 910, 1, 910, 1, 910, 1, 910, 1, 910, 1, 910, 1, + 911, 1, 911, 1, 911, 1, 911, 1, 911, 1, 911, 1, 911, 1, 911, 1, 911, 1, + 911, 1, 912, 1, 912, 1, 912, 1, 912, 1, 912, 1, 912, 1, 912, 1, 912, 1, + 912, 1, 912, 1, 913, 1, 913, 1, 913, 1, 913, 1, 913, 1, 913, 1, 914, 1, + 914, 1, 914, 1, 914, 1, 914, 1, 914, 1, 914, 1, 914, 1, 914, 1, 914, 1, + 914, 1, 914, 1, 914, 1, 914, 1, 915, 1, 915, 1, 915, 1, 915, 1, 915, 1, + 915, 1, 915, 1, 915, 1, 915, 1, 915, 1, 915, 1, 916, 1, 916, 1, 916, 1, + 916, 1, 916, 1, 916, 1, 916, 1, 916, 1, 916, 1, 917, 1, 917, 1, 917, 1, + 917, 1, 917, 1, 917, 1, 917, 1, 917, 1, 918, 1, 918, 1, 918, 1, 918, 1, + 918, 1, 918, 1, 918, 1, 919, 1, 919, 1, 919, 1, 919, 1, 919, 1, 919, 1, + 919, 1, 919, 1, 919, 1, 920, 1, 920, 1, 920, 1, 920, 1, 920, 1, 920, 1, + 920, 1, 920, 1, 920, 1, 920, 1, 920, 1, 920, 1, 920, 1, 921, 1, 921, 1, + 921, 1, 921, 1, 921, 1, 921, 1, 921, 1, 921, 1, 922, 1, 922, 1, 922, 1, + 922, 1, 922, 1, 922, 1, 922, 1, 922, 1, 922, 1, 922, 1, 922, 1, 922, 1, + 922, 1, 922, 1, 922, 1, 923, 1, 923, 1, 923, 1, 923, 1, 923, 1, 923, 1, + 923, 1, 923, 1, 923, 1, 923, 1, 923, 1, 923, 1, 923, 1, 923, 1, 923, 1, + 924, 1, 924, 1, 924, 1, 924, 1, 924, 1, 924, 1, 924, 1, 924, 1, 925, 1, + 925, 1, 925, 1, 925, 1, 925, 1, 925, 1, 925, 1, 925, 1, 925, 1, 925, 1, + 925, 1, 925, 1, 925, 1, 926, 1, 926, 1, 926, 1, 926, 1, 926, 1, 926, 1, + 926, 1, 926, 1, 926, 1, 926, 1, 926, 1, 926, 1, 926, 1, 926, 1, 926, 1, + 927, 1, 927, 1, 927, 1, 927, 1, 927, 1, 927, 1, 928, 1, 928, 1, 928, 1, + 928, 1, 928, 1, 928, 1, 929, 1, 929, 1, 929, 1, 929, 1, 929, 1, 929, 1, + 929, 1, 930, 1, 930, 1, 930, 1, 930, 1, 930, 1, 930, 1, 930, 1, 930, 1, + 930, 1, 930, 1, 930, 1, 930, 1, 930, 1, 931, 1, 931, 1, 931, 1, 931, 1, + 931, 1, 931, 1, 931, 1, 931, 1, 931, 1, 931, 1, 931, 1, 931, 1, 932, 1, + 932, 1, 932, 1, 932, 1, 932, 1, 932, 1, 932, 1, 932, 1, 932, 1, 932, 1, + 932, 1, 932, 1, 932, 1, 932, 1, 932, 1, 932, 1, 932, 1, 932, 1, 932, 1, + 933, 1, 933, 1, 933, 1, 933, 1, 933, 1, 933, 1, 933, 1, 933, 1, 933, 1, + 933, 1, 933, 1, 933, 1, 933, 1, 933, 1, 933, 1, 933, 1, 933, 1, 933, 1, + 934, 1, 934, 1, 934, 1, 935, 1, 935, 1, 935, 1, 935, 1, 935, 1, 935, 1, + 935, 1, 935, 1, 935, 1, 935, 1, 936, 1, 936, 1, 936, 1, 936, 1, 936, 1, + 936, 1, 936, 1, 937, 1, 937, 1, 937, 1, 937, 1, 938, 1, 938, 1, 938, 1, + 938, 1, 938, 1, 938, 1, 939, 1, 939, 1, 939, 1, 939, 1, 939, 1, 940, 1, + 940, 1, 940, 1, 940, 1, 940, 1, 940, 1, 941, 1, 941, 1, 941, 1, 941, 1, + 941, 1, 942, 1, 942, 1, 942, 1, 942, 1, 942, 1, 942, 1, 943, 1, 943, 1, + 943, 1, 943, 1, 943, 1, 943, 1, 943, 1, 943, 1, 943, 1, 944, 1, 944, 1, + 944, 1, 944, 1, 944, 1, 944, 1, 944, 1, 944, 1, 944, 1, 945, 1, 945, 1, + 945, 1, 945, 1, 945, 1, 945, 1, 945, 1, 945, 1, 945, 1, 946, 1, 946, 1, + 946, 1, 946, 1, 946, 1, 946, 1, 946, 1, 946, 1, 946, 1, 946, 1, 946, 1, + 946, 1, 946, 1, 946, 1, 946, 1, 946, 1, 947, 1, 947, 1, 947, 1, 947, 1, + 947, 1, 947, 1, 947, 1, 947, 1, 947, 1, 947, 1, 947, 1, 947, 1, 948, 1, + 948, 1, 948, 1, 948, 1, 948, 1, 948, 1, 948, 1, 948, 1, 948, 1, 948, 1, + 948, 1, 948, 1, 949, 1, 949, 1, 949, 1, 949, 1, 949, 1, 949, 1, 949, 1, + 949, 1, 949, 1, 950, 1, 950, 1, 950, 1, 950, 1, 950, 1, 950, 1, 950, 1, + 950, 1, 950, 1, 950, 1, 950, 1, 950, 1, 950, 1, 950, 1, 951, 1, 951, 1, + 951, 1, 951, 1, 951, 1, 951, 1, 951, 1, 951, 1, 951, 1, 951, 1, 951, 1, + 951, 1, 952, 1, 952, 1, 952, 1, 952, 1, 952, 1, 952, 1, 952, 1, 952, 1, + 952, 1, 952, 1, 952, 1, 953, 1, 953, 1, 953, 1, 953, 1, 953, 1, 953, 1, + 953, 1, 953, 1, 953, 1, 953, 1, 954, 1, 954, 1, 954, 1, 954, 1, 955, 1, + 955, 1, 955, 1, 955, 1, 955, 1, 955, 1, 955, 1, 955, 1, 955, 1, 955, 1, + 955, 1, 955, 1, 955, 1, 955, 1, 956, 1, 956, 1, 956, 1, 956, 1, 956, 1, + 956, 1, 956, 1, 956, 1, 956, 1, 956, 1, 956, 1, 956, 1, 956, 1, 957, 1, + 957, 1, 957, 1, 957, 1, 957, 1, 957, 1, 957, 1, 957, 1, 957, 1, 957, 1, + 958, 1, 958, 1, 958, 1, 958, 1, 958, 1, 958, 1, 958, 1, 958, 1, 958, 1, + 958, 1, 958, 1, 958, 1, 958, 1, 958, 1, 958, 1, 959, 1, 959, 1, 959, 1, + 959, 1, 959, 1, 959, 1, 959, 1, 959, 1, 959, 1, 959, 1, 959, 1, 959, 1, + 959, 1, 959, 1, 960, 1, 960, 1, 960, 1, 960, 1, 960, 1, 960, 1, 960, 1, + 960, 1, 960, 1, 960, 1, 960, 1, 960, 1, 960, 1, 960, 1, 961, 1, 961, 1, + 961, 1, 961, 1, 961, 1, 961, 1, 961, 1, 961, 1, 961, 1, 961, 1, 961, 1, + 961, 1, 961, 1, 962, 1, 962, 1, 962, 1, 962, 1, 962, 1, 962, 1, 962, 1, + 962, 1, 962, 1, 962, 1, 962, 1, 962, 1, 962, 1, 962, 1, 962, 1, 962, 1, + 962, 1, 962, 1, 962, 1, 962, 1, 962, 1, 962, 1, 962, 1, 962, 1, 963, 1, + 963, 1, 963, 1, 963, 1, 963, 1, 963, 1, 963, 1, 963, 1, 963, 1, 963, 1, + 963, 1, 963, 1, 963, 1, 963, 1, 963, 1, 963, 1, 963, 1, 963, 1, 963, 1, + 963, 1, 963, 1, 963, 1, 963, 1, 964, 1, 964, 1, 964, 1, 964, 1, 964, 1, + 964, 1, 964, 1, 964, 1, 964, 1, 964, 1, 964, 1, 964, 1, 964, 1, 964, 1, + 964, 1, 964, 1, 964, 1, 964, 1, 964, 1, 965, 1, 965, 1, 965, 1, 965, 1, + 965, 1, 965, 1, 965, 1, 965, 1, 965, 1, 965, 1, 965, 1, 965, 1, 965, 1, + 965, 1, 965, 1, 965, 1, 965, 1, 965, 1, 966, 1, 966, 1, 966, 1, 966, 1, + 966, 1, 966, 1, 966, 1, 966, 1, 966, 1, 966, 1, 966, 1, 966, 1, 966, 1, + 966, 1, 966, 1, 966, 1, 966, 1, 966, 1, 966, 1, 966, 1, 966, 1, 967, 1, + 967, 1, 967, 1, 967, 1, 967, 1, 967, 1, 967, 1, 967, 1, 967, 1, 967, 1, + 967, 1, 967, 1, 967, 1, 967, 1, 967, 1, 967, 1, 967, 1, 967, 1, 967, 1, + 967, 1, 968, 1, 968, 1, 968, 1, 968, 1, 968, 1, 968, 1, 968, 1, 968, 1, + 968, 1, 968, 1, 968, 1, 969, 1, 969, 1, 969, 1, 969, 1, 969, 1, 969, 1, + 969, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, + 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 971, 1, 971, 1, 971, 1, + 971, 1, 971, 1, 971, 1, 971, 1, 971, 1, 971, 1, 971, 1, 971, 1, 971, 1, + 971, 1, 971, 1, 971, 1, 971, 1, 971, 1, 972, 1, 972, 1, 972, 1, 972, 1, + 972, 1, 972, 1, 972, 1, 972, 1, 972, 1, 972, 1, 973, 1, 973, 1, 973, 1, + 973, 1, 974, 1, 974, 1, 974, 1, 974, 1, 974, 1, 974, 1, 974, 1, 974, 1, + 974, 1, 974, 1, 974, 1, 974, 1, 974, 1, 975, 1, 975, 1, 975, 1, 975, 1, + 976, 1, 976, 1, 976, 1, 976, 1, 976, 1, 976, 1, 976, 1, 976, 1, 976, 1, + 977, 1, 977, 1, 977, 1, 977, 1, 977, 1, 977, 1, 977, 1, 977, 1, 977, 1, + 977, 1, 977, 1, 978, 1, 978, 1, 978, 1, 978, 1, 978, 1, 978, 1, 978, 1, + 978, 1, 978, 1, 978, 1, 978, 1, 978, 1, 979, 1, 979, 1, 979, 1, 980, 1, + 980, 1, 980, 1, 980, 1, 980, 1, 980, 1, 980, 1, 980, 1, 980, 1, 980, 1, + 980, 1, 980, 1, 980, 1, 980, 1, 981, 1, 981, 1, 981, 1, 981, 1, 981, 1, + 981, 1, 981, 1, 981, 1, 981, 1, 981, 1, 981, 1, 981, 1, 981, 1, 982, 1, + 982, 1, 982, 1, 982, 1, 982, 1, 982, 1, 982, 1, 983, 1, 983, 1, 983, 1, + 983, 1, 983, 1, 983, 1, 983, 1, 983, 1, 983, 1, 983, 1, 983, 1, 983, 1, + 983, 1, 984, 1, 984, 1, 984, 1, 984, 1, 984, 1, 984, 1, 984, 1, 984, 1, + 984, 1, 984, 1, 984, 1, 984, 1, 985, 1, 985, 1, 985, 1, 985, 1, 985, 1, + 985, 1, 985, 1, 985, 1, 985, 1, 985, 1, 985, 1, 985, 1, 985, 1, 985, 1, + 985, 1, 985, 1, 986, 1, 986, 1, 986, 1, 986, 1, 986, 1, 986, 1, 986, 1, + 986, 1, 986, 1, 986, 1, 986, 1, 986, 1, 986, 1, 986, 1, 986, 1, 987, 1, + 987, 1, 987, 1, 987, 1, 988, 1, 988, 1, 988, 1, 988, 1, 988, 1, 988, 1, + 989, 1, 989, 1, 989, 1, 989, 1, 989, 1, 989, 1, 990, 1, 990, 1, 990, 1, + 990, 1, 990, 1, 990, 1, 990, 1, 990, 1, 991, 1, 991, 1, 991, 1, 991, 1, + 991, 1, 992, 1, 992, 1, 992, 1, 992, 1, 992, 1, 992, 1, 992, 1, 993, 1, + 993, 1, 993, 1, 993, 1, 993, 1, 993, 1, 993, 1, 993, 1, 993, 1, 993, 1, + 993, 1, 993, 1, 993, 1, 994, 1, 994, 1, 994, 1, 994, 1, 994, 1, 994, 1, + 994, 1, 994, 1, 994, 1, 994, 1, 994, 1, 994, 1, 994, 1, 995, 1, 995, 1, + 995, 1, 995, 1, 995, 1, 995, 1, 995, 1, 995, 1, 996, 1, 996, 1, 996, 1, + 996, 1, 996, 1, 996, 1, 997, 1, 997, 1, 997, 1, 997, 1, 997, 1, 997, 1, + 997, 1, 997, 1, 997, 1, 997, 1, 998, 1, 998, 1, 998, 1, 998, 1, 998, 1, + 999, 1, 999, 1, 999, 1, 999, 1, 999, 1, 999, 1, 1000, 1, 1000, 1, 1000, + 1, 1000, 1, 1000, 1, 1000, 1, 1000, 1, 1000, 1, 1000, 1, 1000, 1, 1000, + 1, 1000, 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, + 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, + 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, + 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1002, 1, 1002, 1, 1002, 1, 1002, + 1, 1002, 1, 1002, 1, 1002, 1, 1002, 1, 1002, 1, 1002, 1, 1002, 1, 1002, + 1, 1002, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1004, 1, 1004, 1, 1004, + 1, 1004, 1, 1004, 1, 1005, 1, 1005, 1, 1005, 1, 1005, 1, 1005, 1, 1006, + 1, 1006, 1, 1006, 1, 1006, 1, 1006, 1, 1006, 1, 1006, 1, 1006, 1, 1006, + 1, 1006, 1, 1006, 1, 1006, 1, 1007, 1, 1007, 1, 1007, 1, 1007, 1, 1007, + 1, 1008, 1, 1008, 1, 1008, 1, 1008, 1, 1009, 1, 1009, 1, 1009, 1, 1009, + 1, 1009, 1, 1009, 1, 1010, 1, 1010, 1, 1010, 1, 1010, 1, 1010, 1, 1010, + 1, 1010, 1, 1010, 1, 1011, 1, 1011, 1, 1011, 1, 1011, 1, 1011, 1, 1011, + 1, 1011, 1, 1011, 1, 1011, 1, 1011, 1, 1011, 1, 1011, 1, 1011, 1, 1011, + 1, 1011, 1, 1011, 1, 1011, 1, 1011, 1, 1011, 1, 1011, 1, 1011, 1, 1011, + 1, 1011, 1, 1011, 1, 1011, 1, 1011, 1, 1011, 1, 1011, 1, 1012, 1, 1012, + 1, 1012, 1, 1012, 1, 1012, 1, 1013, 1, 1013, 1, 1013, 1, 1013, 1, 1013, + 1, 1014, 1, 1014, 1, 1014, 1, 1014, 1, 1014, 1, 1014, 1, 1014, 1, 1014, + 1, 1014, 1, 1014, 1, 1014, 1, 1015, 1, 1015, 1, 1015, 1, 1015, 1, 1015, + 1, 1015, 1, 1015, 1, 1016, 1, 1016, 1, 1016, 1, 1016, 1, 1016, 1, 1016, + 1, 1016, 1, 1016, 1, 1016, 1, 1016, 1, 1016, 1, 1016, 1, 1017, 1, 1017, + 1, 1017, 1, 1017, 1, 1017, 1, 1017, 1, 1017, 1, 1017, 1, 1018, 1, 1018, + 1, 1018, 1, 1018, 1, 1018, 1, 1018, 1, 1018, 1, 1018, 1, 1018, 1, 1018, + 1, 1018, 1, 1018, 1, 1019, 1, 1019, 1, 1019, 1, 1019, 1, 1019, 1, 1019, + 1, 1019, 1, 1019, 1, 1019, 1, 1019, 1, 1020, 1, 1020, 1, 1020, 1, 1020, + 1, 1020, 1, 1020, 1, 1020, 1, 1020, 1, 1020, 1, 1021, 1, 1021, 1, 1021, + 1, 1021, 1, 1021, 1, 1021, 1, 1021, 1, 1021, 1, 1021, 1, 1022, 1, 1022, + 1, 1022, 1, 1022, 1, 1022, 1, 1022, 1, 1022, 1, 1022, 1, 1022, 1, 1022, + 1, 1023, 1, 1023, 1, 1023, 1, 1023, 1, 1023, 1, 1023, 1, 1023, 1, 1023, + 1, 1023, 1, 1023, 1, 1023, 1, 1023, 1, 1024, 1, 1024, 1, 1024, 1, 1024, + 1, 1024, 1, 1024, 1, 1024, 1, 1024, 1, 1024, 1, 1024, 1, 1024, 1, 1024, + 1, 1025, 1, 1025, 1, 1025, 1, 1025, 1, 1025, 1, 1025, 1, 1025, 1, 1025, + 1, 1025, 1, 1025, 1, 1025, 1, 1026, 1, 1026, 1, 1026, 1, 1026, 1, 1026, + 1, 1026, 1, 1026, 1, 1026, 1, 1026, 1, 1026, 1, 1026, 1, 1026, 1, 1026, + 1, 1026, 1, 1027, 1, 1027, 1, 1027, 1, 1027, 1, 1027, 1, 1027, 1, 1027, + 1, 1027, 1, 1027, 1, 1027, 1, 1027, 1, 1027, 1, 1027, 1, 1028, 1, 1028, + 1, 1028, 1, 1028, 1, 1028, 1, 1028, 1, 1028, 1, 1028, 1, 1028, 1, 1028, + 1, 1028, 1, 1028, 1, 1029, 1, 1029, 1, 1029, 1, 1029, 1, 1029, 1, 1029, + 1, 1029, 1, 1029, 1, 1029, 1, 1029, 1, 1029, 1, 1029, 1, 1030, 1, 1030, + 1, 1030, 1, 1030, 1, 1030, 1, 1030, 1, 1030, 1, 1030, 1, 1030, 1, 1030, + 1, 1030, 1, 1030, 1, 1031, 1, 1031, 1, 1031, 1, 1031, 1, 1031, 1, 1031, + 1, 1031, 1, 1031, 1, 1031, 1, 1031, 1, 1031, 1, 1031, 1, 1032, 1, 1032, + 1, 1032, 1, 1032, 1, 1032, 1, 1032, 1, 1032, 1, 1032, 1, 1032, 1, 1032, + 1, 1033, 1, 1033, 1, 1033, 1, 1033, 1, 1033, 1, 1033, 1, 1033, 1, 1033, + 1, 1033, 1, 1033, 1, 1033, 1, 1033, 1, 1033, 1, 1033, 1, 1033, 1, 1033, + 1, 1034, 1, 1034, 1, 1034, 1, 1034, 1, 1034, 1, 1034, 1, 1034, 1, 1034, + 1, 1034, 1, 1034, 1, 1034, 1, 1034, 1, 1034, 1, 1034, 1, 1034, 1, 1034, + 1, 1034, 1, 1034, 1, 1034, 1, 1034, 1, 1035, 1, 1035, 1, 1035, 1, 1035, + 1, 1035, 1, 1035, 1, 1035, 1, 1035, 1, 1035, 1, 1035, 1, 1035, 1, 1035, + 1, 1035, 1, 1035, 1, 1035, 1, 1035, 1, 1035, 1, 1035, 1, 1035, 1, 1036, + 1, 1036, 1, 1036, 1, 1036, 1, 1036, 1, 1036, 1, 1036, 1, 1036, 1, 1036, + 1, 1036, 1, 1036, 1, 1036, 1, 1036, 1, 1036, 1, 1036, 1, 1036, 1, 1036, + 1, 1036, 1, 1036, 1, 1037, 1, 1037, 1, 1037, 1, 1037, 1, 1037, 1, 1037, + 1, 1037, 1, 1037, 1, 1037, 1, 1037, 1, 1037, 1, 1037, 1, 1037, 1, 1037, + 1, 1037, 1, 1037, 1, 1037, 1, 1037, 1, 1037, 1, 1037, 1, 1037, 1, 1037, + 1, 1037, 1, 1037, 1, 1037, 1, 1037, 1, 1037, 1, 1037, 1, 1037, 1, 1037, + 1, 1038, 1, 1038, 1, 1038, 1, 1038, 1, 1038, 1, 1038, 1, 1038, 1, 1038, + 1, 1038, 1, 1038, 1, 1038, 1, 1038, 1, 1038, 1, 1038, 1, 1038, 1, 1038, + 1, 1038, 1, 1038, 1, 1038, 1, 1038, 1, 1038, 1, 1038, 1, 1038, 1, 1038, + 1, 1038, 1, 1038, 1, 1038, 1, 1038, 1, 1038, 1, 1039, 1, 1039, 1, 1039, + 1, 1039, 1, 1039, 1, 1039, 1, 1039, 1, 1039, 1, 1039, 1, 1039, 1, 1039, + 1, 1039, 1, 1039, 1, 1039, 1, 1039, 1, 1039, 1, 1039, 1, 1039, 1, 1039, + 1, 1039, 1, 1040, 1, 1040, 1, 1040, 1, 1040, 1, 1040, 1, 1040, 1, 1040, + 1, 1040, 1, 1040, 1, 1040, 1, 1040, 1, 1040, 1, 1040, 1, 1040, 1, 1040, + 1, 1040, 1, 1040, 1, 1040, 1, 1040, 1, 1041, 1, 1041, 1, 1041, 1, 1041, + 1, 1041, 1, 1041, 1, 1041, 1, 1041, 1, 1041, 1, 1041, 1, 1041, 1, 1041, + 1, 1041, 1, 1042, 1, 1042, 1, 1042, 1, 1042, 1, 1042, 1, 1042, 1, 1042, + 1, 1042, 1, 1042, 1, 1042, 1, 1042, 1, 1042, 1, 1042, 1, 1042, 1, 1042, + 1, 1042, 1, 1043, 1, 1043, 1, 1043, 1, 1043, 1, 1043, 1, 1043, 1, 1043, + 1, 1043, 1, 1043, 1, 1043, 1, 1043, 1, 1043, 1, 1043, 1, 1043, 1, 1043, + 1, 1043, 1, 1044, 1, 1044, 1, 1044, 1, 1044, 1, 1044, 1, 1044, 1, 1044, + 1, 1044, 1, 1044, 1, 1044, 1, 1044, 1, 1044, 1, 1044, 1, 1044, 1, 1044, + 1, 1045, 1, 1045, 1, 1045, 1, 1045, 1, 1045, 1, 1045, 1, 1045, 1, 1045, + 1, 1045, 1, 1045, 1, 1045, 1, 1045, 1, 1045, 1, 1045, 1, 1045, 1, 1045, + 1, 1045, 1, 1046, 1, 1046, 1, 1046, 1, 1046, 1, 1046, 1, 1046, 1, 1046, + 1, 1046, 1, 1046, 1, 1046, 1, 1046, 1, 1046, 1, 1046, 1, 1046, 1, 1046, + 1, 1046, 1, 1047, 1, 1047, 1, 1047, 1, 1047, 1, 1047, 1, 1047, 1, 1047, + 1, 1047, 1, 1047, 1, 1047, 1, 1047, 1, 1047, 1, 1047, 1, 1047, 1, 1048, + 1, 1048, 1, 1048, 1, 1048, 1, 1048, 1, 1048, 1, 1048, 1, 1048, 1, 1048, + 1, 1048, 1, 1048, 1, 1048, 1, 1049, 1, 1049, 1, 1049, 1, 1049, 1, 1049, + 1, 1049, 1, 1049, 1, 1049, 1, 1049, 1, 1049, 1, 1049, 1, 1050, 1, 1050, + 1, 1050, 1, 1050, 1, 1050, 1, 1050, 1, 1050, 1, 1050, 1, 1050, 1, 1050, + 1, 1050, 1, 1050, 1, 1051, 1, 1051, 1, 1051, 1, 1051, 1, 1051, 1, 1051, + 1, 1051, 1, 1051, 1, 1051, 1, 1051, 1, 1051, 1, 1051, 1, 1051, 1, 1051, + 1, 1051, 1, 1051, 1, 1052, 1, 1052, 1, 1052, 1, 1052, 1, 1052, 1, 1052, + 1, 1052, 1, 1052, 1, 1052, 1, 1052, 1, 1052, 1, 1052, 1, 1052, 1, 1052, + 1, 1052, 1, 1053, 1, 1053, 1, 1053, 1, 1053, 1, 1053, 1, 1053, 1, 1053, + 1, 1053, 1, 1053, 1, 1053, 1, 1053, 1, 1053, 1, 1053, 1, 1053, 1, 1053, + 1, 1053, 1, 1053, 1, 1053, 1, 1053, 1, 1053, 1, 1053, 1, 1053, 1, 1054, + 1, 1054, 1, 1054, 1, 1054, 1, 1054, 1, 1054, 1, 1054, 1, 1054, 1, 1054, + 1, 1054, 1, 1054, 1, 1054, 1, 1054, 1, 1054, 1, 1054, 1, 1054, 1, 1054, + 1, 1054, 1, 1054, 1, 1054, 1, 1054, 1, 1055, 1, 1055, 1, 1055, 1, 1055, + 1, 1055, 1, 1055, 1, 1055, 1, 1055, 1, 1055, 1, 1055, 1, 1055, 1, 1055, + 1, 1055, 1, 1055, 1, 1055, 1, 1055, 1, 1055, 1, 1056, 1, 1056, 1, 1056, + 1, 1056, 1, 1056, 1, 1056, 1, 1056, 1, 1056, 1, 1056, 1, 1056, 1, 1056, + 1, 1056, 1, 1056, 1, 1056, 1, 1056, 1, 1056, 1, 1056, 1, 1056, 1, 1056, + 1, 1057, 1, 1057, 1, 1057, 1, 1057, 1, 1057, 1, 1057, 1, 1057, 1, 1057, + 1, 1057, 1, 1057, 1, 1057, 1, 1057, 1, 1057, 1, 1057, 1, 1057, 1, 1057, + 1, 1057, 1, 1057, 1, 1057, 1, 1057, 1, 1058, 1, 1058, 1, 1058, 1, 1058, + 1, 1058, 1, 1058, 1, 1058, 1, 1058, 1, 1058, 1, 1058, 1, 1058, 1, 1058, + 1, 1058, 1, 1059, 1, 1059, 1, 1059, 1, 1059, 1, 1059, 1, 1059, 1, 1059, + 1, 1059, 1, 1059, 1, 1059, 1, 1059, 1, 1059, 1, 1060, 1, 1060, 1, 1060, + 1, 1060, 1, 1060, 1, 1060, 1, 1060, 1, 1060, 1, 1060, 1, 1060, 1, 1060, + 1, 1060, 1, 1060, 1, 1060, 1, 1060, 1, 1060, 1, 1060, 1, 1061, 1, 1061, + 1, 1061, 1, 1061, 1, 1061, 1, 1061, 1, 1061, 1, 1061, 1, 1061, 1, 1061, + 1, 1061, 1, 1061, 1, 1061, 1, 1061, 1, 1061, 1, 1061, 1, 1062, 1, 1062, + 1, 1062, 1, 1062, 1, 1062, 1, 1062, 1, 1062, 1, 1062, 1, 1062, 1, 1062, + 1, 1063, 1, 1063, 1, 1063, 1, 1063, 1, 1063, 1, 1063, 1, 1063, 1, 1063, + 1, 1063, 1, 1063, 1, 1063, 1, 1063, 1, 1063, 1, 1063, 1, 1063, 1, 1063, + 1, 1064, 1, 1064, 1, 1064, 1, 1064, 1, 1064, 1, 1064, 1, 1064, 1, 1064, + 1, 1064, 1, 1064, 1, 1064, 1, 1064, 1, 1064, 1, 1064, 1, 1064, 1, 1065, + 1, 1065, 1, 1065, 1, 1065, 1, 1065, 1, 1065, 1, 1065, 1, 1065, 1, 1065, + 1, 1065, 1, 1065, 1, 1065, 1, 1065, 1, 1065, 1, 1065, 1, 1065, 1, 1065, + 1, 1065, 1, 1065, 1, 1066, 1, 1066, 1, 1066, 1, 1066, 1, 1066, 1, 1066, + 1, 1066, 1, 1066, 1, 1066, 1, 1066, 1, 1066, 1, 1066, 1, 1066, 1, 1066, + 1, 1066, 1, 1066, 1, 1066, 1, 1066, 1, 1067, 1, 1067, 1, 1067, 1, 1067, + 1, 1067, 1, 1067, 1, 1067, 1, 1067, 1, 1068, 1, 1068, 1, 1068, 1, 1068, + 1, 1068, 1, 1068, 1, 1068, 1, 1068, 1, 1068, 1, 1068, 1, 1068, 1, 1068, + 1, 1068, 1, 1068, 1, 1069, 1, 1069, 1, 1069, 1, 1069, 1, 1069, 1, 1069, + 1, 1069, 1, 1069, 1, 1069, 1, 1069, 1, 1069, 1, 1069, 1, 1069, 1, 1069, + 1, 1069, 1, 1069, 1, 1069, 1, 1070, 1, 1070, 1, 1070, 1, 1070, 1, 1070, + 1, 1070, 1, 1070, 1, 1070, 1, 1070, 1, 1070, 1, 1070, 1, 1071, 1, 1071, + 1, 1071, 1, 1071, 1, 1071, 1, 1071, 1, 1071, 1, 1071, 1, 1071, 1, 1072, + 1, 1072, 1, 1072, 1, 1072, 1, 1072, 1, 1072, 1, 1072, 1, 1072, 1, 1072, + 1, 1072, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1074, 1, 1074, + 1, 1074, 1, 1074, 1, 1074, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, + 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, + 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1076, 1, 1076, 1, 1076, 1, 1076, + 1, 1076, 1, 1076, 1, 1076, 1, 1076, 1, 1077, 1, 1077, 1, 1077, 1, 1077, + 1, 1077, 1, 1077, 1, 1077, 1, 1077, 1, 1077, 1, 1077, 1, 1077, 1, 1077, + 1, 1077, 1, 1077, 1, 1077, 1, 1077, 1, 1078, 1, 1078, 1, 1078, 1, 1078, + 1, 1078, 1, 1078, 1, 1078, 1, 1078, 1, 1079, 1, 1079, 1, 1079, 1, 1079, + 1, 1079, 1, 1079, 1, 1079, 1, 1079, 1, 1079, 1, 1079, 1, 1079, 1, 1079, + 1, 1080, 1, 1080, 1, 1080, 1, 1080, 1, 1081, 1, 1081, 1, 1081, 1, 1081, + 1, 1081, 1, 1081, 1, 1081, 1, 1081, 1, 1081, 1, 1082, 1, 1082, 1, 1082, + 1, 1082, 1, 1082, 1, 1082, 1, 1082, 1, 1082, 1, 1082, 1, 1082, 1, 1082, + 1, 1082, 1, 1082, 1, 1083, 1, 1083, 1, 1083, 1, 1083, 1, 1083, 1, 1083, + 1, 1083, 1, 1083, 1, 1083, 1, 1083, 1, 1083, 1, 1083, 1, 1083, 1, 1083, + 1, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1084, + 1, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1085, 1, 1085, 1, 1085, 1, 1085, + 1, 1085, 1, 1085, 1, 1085, 1, 1085, 1, 1085, 1, 1085, 1, 1085, 1, 1085, + 1, 1086, 1, 1086, 1, 1086, 1, 1086, 1, 1086, 1, 1086, 1, 1086, 1, 1086, + 1, 1087, 1, 1087, 1, 1087, 1, 1087, 1, 1087, 1, 1087, 1, 1087, 1, 1087, + 1, 1087, 1, 1087, 1, 1088, 1, 1088, 1, 1088, 1, 1088, 1, 1088, 1, 1088, + 1, 1088, 1, 1088, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, + 1, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1090, 1, 1090, 1, 1090, + 1, 1090, 1, 1090, 1, 1090, 1, 1090, 1, 1090, 1, 1090, 1, 1090, 1, 1090, + 1, 1090, 1, 1090, 1, 1090, 1, 1090, 1, 1090, 1, 1090, 1, 1090, 1, 1090, + 1, 1090, 1, 1091, 1, 1091, 1, 1091, 1, 1091, 1, 1091, 1, 1091, 1, 1092, + 1, 1092, 1, 1092, 1, 1092, 1, 1092, 1, 1092, 1, 1092, 1, 1092, 1, 1092, + 1, 1092, 1, 1092, 1, 1093, 1, 1093, 1, 1093, 1, 1093, 1, 1093, 1, 1093, + 1, 1093, 1, 1093, 1, 1093, 1, 1093, 1, 1093, 1, 1093, 1, 1093, 1, 1093, + 1, 1093, 1, 1093, 1, 1093, 1, 1093, 1, 1093, 1, 1093, 1, 1094, 1, 1094, + 1, 1094, 1, 1094, 1, 1094, 1, 1094, 1, 1095, 1, 1095, 1, 1095, 1, 1095, + 1, 1095, 1, 1095, 1, 1095, 1, 1095, 1, 1095, 1, 1095, 1, 1095, 1, 1095, + 1, 1095, 1, 1095, 1, 1095, 1, 1096, 1, 1096, 1, 1096, 1, 1096, 1, 1096, + 1, 1096, 1, 1096, 1, 1096, 1, 1096, 1, 1096, 1, 1097, 1, 1097, 1, 1097, + 1, 1097, 1, 1097, 1, 1097, 1, 1098, 1, 1098, 1, 1098, 1, 1098, 1, 1098, + 1, 1099, 1, 1099, 1, 1099, 1, 1099, 1, 1099, 1, 1099, 1, 1099, 1, 1099, + 1, 1099, 1, 1099, 1, 1099, 1, 1100, 1, 1100, 1, 1100, 1, 1100, 1, 1100, + 1, 1100, 1, 1100, 1, 1100, 1, 1100, 1, 1100, 1, 1100, 1, 1100, 1, 1100, + 1, 1100, 1, 1100, 1, 1100, 1, 1100, 1, 1100, 1, 1100, 1, 1100, 1, 1100, + 1, 1100, 1, 1100, 1, 1100, 1, 1100, 1, 1100, 1, 1100, 1, 1101, 1, 1101, + 1, 1101, 1, 1101, 1, 1101, 1, 1101, 1, 1101, 1, 1101, 1, 1101, 1, 1101, + 1, 1101, 1, 1102, 1, 1102, 1, 1102, 1, 1102, 1, 1102, 1, 1102, 1, 1102, + 1, 1102, 1, 1102, 1, 1102, 1, 1102, 1, 1102, 1, 1102, 1, 1102, 1, 1102, + 1, 1102, 1, 1102, 1, 1103, 1, 1103, 1, 1103, 1, 1103, 1, 1103, 1, 1103, + 1, 1103, 1, 1103, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, + 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, + 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, + 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, + 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1105, 1, 1105, 1, 1105, 1, 1105, + 1, 1105, 1, 1105, 1, 1105, 1, 1105, 1, 1106, 1, 1106, 1, 1106, 1, 1106, + 1, 1106, 1, 1106, 1, 1106, 1, 1106, 1, 1106, 1, 1106, 1, 1106, 1, 1107, + 1, 1107, 1, 1107, 1, 1107, 1, 1107, 1, 1107, 1, 1107, 1, 1107, 1, 1107, + 1, 1107, 1, 1107, 1, 1107, 1, 1107, 1, 1107, 1, 1108, 1, 1108, 1, 1108, + 1, 1108, 1, 1108, 1, 1108, 1, 1108, 1, 1109, 1, 1109, 1, 1109, 1, 1109, + 1, 1109, 1, 1109, 1, 1109, 1, 1109, 1, 1109, 1, 1110, 1, 1110, 1, 1111, + 1, 1111, 1, 1112, 1, 1112, 1, 1112, 1, 1113, 1, 1113, 1, 1113, 1, 1114, + 1, 1114, 1, 1114, 1, 1115, 1, 1115, 1, 1115, 1, 1116, 1, 1116, 1, 1116, + 1, 1117, 1, 1117, 1, 1117, 1, 1118, 1, 1118, 1, 1118, 1, 1119, 1, 1119, + 1, 1119, 1, 1120, 1, 1120, 1, 1120, 1, 1121, 1, 1121, 1, 1122, 1, 1122, + 1, 1123, 1, 1123, 1, 1124, 1, 1124, 1, 1125, 1, 1125, 1, 1126, 1, 1126, + 1, 1126, 1, 1126, 1, 1127, 1, 1127, 1, 1127, 1, 1127, 1, 1128, 1, 1128, + 1, 1129, 1, 1129, 1, 1130, 1, 1130, 1, 1131, 1, 1131, 1, 1132, 1, 1132, + 1, 1133, 1, 1133, 1, 1134, 1, 1134, 1, 1135, 1, 1135, 1, 1136, 1, 1136, + 1, 1137, 1, 1137, 1, 1138, 1, 1138, 1, 1139, 1, 1139, 1, 1140, 1, 1140, + 1, 1141, 1, 1141, 1, 1142, 1, 1142, 1, 1143, 1, 1143, 1, 1144, 1, 1144, + 1, 1145, 1, 1145, 1, 1146, 1, 1146, 1, 1147, 1, 1147, 1, 1148, 1, 1148, + 1, 1149, 1, 1149, 1, 1149, 3, 1149, 13493, 8, 1149, 1, 1150, 1, 1150, 1, + 1150, 1, 1150, 1, 1151, 4, 1151, 13500, 8, 1151, 11, 1151, 12, 1151, 13501, + 1, 1151, 1, 1151, 1, 1152, 1, 1152, 1, 1152, 1, 1153, 1, 1153, 1, 1153, + 3, 1153, 13512, 8, 1153, 1, 1154, 4, 1154, 13515, 8, 1154, 11, 1154, 12, + 1154, 13516, 1, 1155, 1, 1155, 1, 1155, 1, 1155, 1, 1155, 4, 1155, 13524, + 8, 1155, 11, 1155, 12, 1155, 13525, 1, 1155, 1, 1155, 1, 1155, 1, 1155, + 1, 1155, 1, 1155, 4, 1155, 13534, 8, 1155, 11, 1155, 12, 1155, 13535, 3, + 1155, 13538, 8, 1155, 1, 1156, 5, 1156, 13541, 8, 1156, 10, 1156, 12, 1156, + 13544, 9, 1156, 1, 1156, 1, 1156, 4, 1156, 13548, 8, 1156, 11, 1156, 12, + 1156, 13549, 1, 1156, 4, 1156, 13553, 8, 1156, 11, 1156, 12, 1156, 13554, + 1, 1156, 1, 1156, 1, 1156, 1, 1156, 5, 1156, 13561, 8, 1156, 10, 1156, + 12, 1156, 13564, 9, 1156, 1, 1156, 1, 1156, 4, 1156, 13568, 8, 1156, 11, + 1156, 12, 1156, 13569, 1, 1156, 1, 1156, 1, 1156, 4, 1156, 13575, 8, 1156, + 11, 1156, 12, 1156, 13576, 1, 1156, 1, 1156, 3, 1156, 13581, 8, 1156, 1, + 1157, 1, 1157, 1, 1157, 1, 1158, 1, 1158, 1, 1159, 1, 1159, 1, 1159, 1, + 1160, 1, 1160, 1, 1160, 1, 1161, 1, 1161, 1, 1162, 1, 1162, 1, 1163, 1, + 1163, 1, 1163, 1, 1164, 1, 1164, 1, 1164, 4, 1164, 13604, 8, 1164, 11, + 1164, 12, 1164, 13605, 3, 1164, 13608, 8, 1164, 1, 1165, 1, 1165, 1, 1165, + 4, 1165, 13613, 8, 1165, 11, 1165, 12, 1165, 13614, 1, 1165, 3, 1165, 13618, + 8, 1165, 1, 1166, 1, 1166, 1, 1166, 1, 1166, 1, 1166, 1, 1166, 1, 1166, + 1, 1166, 1, 1166, 1, 1166, 1, 1166, 1, 1166, 1, 1166, 1, 1166, 1, 1166, + 1, 1166, 1, 1166, 1, 1166, 1, 1166, 1, 1166, 1, 1166, 1, 1166, 1, 1166, + 1, 1166, 1, 1166, 1, 1166, 1, 1166, 1, 1166, 1, 1166, 1, 1166, 1, 1166, + 1, 1166, 1, 1166, 1, 1166, 1, 1166, 1, 1166, 1, 1166, 1, 1166, 1, 1166, + 1, 1166, 1, 1166, 3, 1166, 13661, 8, 1166, 1, 1167, 1, 1167, 3, 1167, 13665, + 8, 1167, 1, 1167, 4, 1167, 13668, 8, 1167, 11, 1167, 12, 1167, 13669, 1, + 1168, 5, 1168, 13673, 8, 1168, 10, 1168, 12, 1168, 13676, 9, 1168, 1, 1168, + 4, 1168, 13679, 8, 1168, 11, 1168, 12, 1168, 13680, 1, 1168, 5, 1168, 13684, + 8, 1168, 10, 1168, 12, 1168, 13687, 9, 1168, 1, 1169, 1, 1169, 1, 1169, + 1, 1169, 1, 1169, 1, 1169, 5, 1169, 13695, 8, 1169, 10, 1169, 12, 1169, + 13698, 9, 1169, 1, 1169, 1, 1169, 1, 1170, 1, 1170, 1, 1170, 1, 1170, 1, + 1170, 1, 1170, 5, 1170, 13708, 8, 1170, 10, 1170, 12, 1170, 13711, 9, 1170, + 1, 1170, 1, 1170, 1, 1171, 1, 1171, 1, 1171, 1, 1171, 5, 1171, 13719, 8, + 1171, 10, 1171, 12, 1171, 13722, 9, 1171, 1, 1171, 1, 1171, 1, 1172, 1, + 1172, 1, 1173, 1, 1173, 1, 1174, 1, 1174, 1, 1174, 4, 1174, 13733, 8, 1174, + 11, 1174, 12, 1174, 13734, 1, 1174, 1, 1174, 1, 1175, 4, 1175, 13740, 8, + 1175, 11, 1175, 12, 1175, 13741, 1, 1175, 1, 1175, 4, 1175, 13746, 8, 1175, + 11, 1175, 12, 1175, 13747, 1, 1175, 5, 1175, 13751, 8, 1175, 10, 1175, + 12, 1175, 13754, 9, 1175, 1, 1175, 1, 1175, 5, 1175, 13758, 8, 1175, 10, + 1175, 12, 1175, 13761, 9, 1175, 1, 1175, 1, 1175, 4, 1175, 13765, 8, 1175, + 11, 1175, 12, 1175, 13766, 3, 1175, 13769, 8, 1175, 1, 1176, 1, 1176, 1, + 1176, 1, 1176, 4, 2369, 2382, 13674, 13680, 0, 1177, 1, 1, 3, 2, 5, 3, + 7, 4, 9, 5, 11, 6, 13, 7, 15, 8, 17, 9, 19, 10, 21, 11, 23, 12, 25, 13, + 27, 14, 29, 15, 31, 16, 33, 17, 35, 18, 37, 19, 39, 20, 41, 21, 43, 22, + 45, 23, 47, 24, 49, 25, 51, 26, 53, 27, 55, 28, 57, 29, 59, 30, 61, 31, + 63, 32, 65, 33, 67, 34, 69, 35, 71, 36, 73, 37, 75, 38, 77, 39, 79, 40, + 81, 41, 83, 42, 85, 43, 87, 44, 89, 45, 91, 46, 93, 47, 95, 48, 97, 49, + 99, 50, 101, 51, 103, 52, 105, 53, 107, 54, 109, 55, 111, 56, 113, 57, + 115, 58, 117, 59, 119, 60, 121, 61, 123, 62, 125, 63, 127, 64, 129, 65, + 131, 66, 133, 67, 135, 68, 137, 69, 139, 70, 141, 71, 143, 72, 145, 73, + 147, 74, 149, 75, 151, 76, 153, 77, 155, 78, 157, 79, 159, 80, 161, 81, + 163, 82, 165, 83, 167, 84, 169, 85, 171, 86, 173, 87, 175, 88, 177, 89, + 179, 90, 181, 91, 183, 92, 185, 93, 187, 94, 189, 95, 191, 96, 193, 97, + 195, 98, 197, 99, 199, 100, 201, 101, 203, 102, 205, 103, 207, 104, 209, + 105, 211, 106, 213, 107, 215, 108, 217, 109, 219, 110, 221, 111, 223, 112, + 225, 113, 227, 114, 229, 115, 231, 116, 233, 117, 235, 118, 237, 119, 239, + 120, 241, 121, 243, 122, 245, 123, 247, 124, 249, 125, 251, 126, 253, 127, + 255, 128, 257, 129, 259, 130, 261, 131, 263, 132, 265, 133, 267, 134, 269, + 135, 271, 136, 273, 137, 275, 138, 277, 139, 279, 140, 281, 141, 283, 142, + 285, 143, 287, 144, 289, 145, 291, 146, 293, 147, 295, 148, 297, 149, 299, + 150, 301, 151, 303, 152, 305, 153, 307, 154, 309, 155, 311, 156, 313, 157, + 315, 158, 317, 159, 319, 160, 321, 161, 323, 162, 325, 163, 327, 164, 329, + 165, 331, 166, 333, 167, 335, 168, 337, 169, 339, 170, 341, 171, 343, 172, + 345, 173, 347, 174, 349, 175, 351, 176, 353, 177, 355, 178, 357, 179, 359, + 180, 361, 181, 363, 182, 365, 183, 367, 184, 369, 185, 371, 186, 373, 187, + 375, 188, 377, 189, 379, 190, 381, 191, 383, 192, 385, 193, 387, 194, 389, + 195, 391, 196, 393, 197, 395, 198, 397, 199, 399, 200, 401, 201, 403, 202, + 405, 203, 407, 204, 409, 205, 411, 206, 413, 207, 415, 208, 417, 209, 419, + 210, 421, 211, 423, 212, 425, 213, 427, 214, 429, 215, 431, 216, 433, 217, + 435, 218, 437, 219, 439, 220, 441, 221, 443, 222, 445, 223, 447, 224, 449, + 225, 451, 226, 453, 227, 455, 228, 457, 229, 459, 230, 461, 231, 463, 232, + 465, 233, 467, 234, 469, 235, 471, 236, 473, 237, 475, 238, 477, 239, 479, + 240, 481, 241, 483, 242, 485, 243, 487, 244, 489, 245, 491, 246, 493, 247, + 495, 248, 497, 249, 499, 250, 501, 251, 503, 252, 505, 253, 507, 254, 509, + 255, 511, 256, 513, 257, 515, 258, 517, 259, 519, 260, 521, 261, 523, 262, + 525, 263, 527, 264, 529, 265, 531, 266, 533, 267, 535, 268, 537, 269, 539, + 270, 541, 271, 543, 272, 545, 273, 547, 274, 549, 275, 551, 276, 553, 277, + 555, 278, 557, 279, 559, 280, 561, 281, 563, 282, 565, 283, 567, 284, 569, + 285, 571, 286, 573, 287, 575, 288, 577, 289, 579, 290, 581, 291, 583, 292, + 585, 293, 587, 294, 589, 295, 591, 296, 593, 297, 595, 298, 597, 299, 599, + 300, 601, 301, 603, 302, 605, 303, 607, 304, 609, 305, 611, 306, 613, 307, + 615, 308, 617, 309, 619, 310, 621, 311, 623, 312, 625, 313, 627, 314, 629, + 315, 631, 316, 633, 317, 635, 318, 637, 319, 639, 320, 641, 321, 643, 322, + 645, 323, 647, 324, 649, 325, 651, 326, 653, 327, 655, 328, 657, 329, 659, + 330, 661, 331, 663, 332, 665, 333, 667, 334, 669, 335, 671, 336, 673, 337, + 675, 338, 677, 339, 679, 340, 681, 341, 683, 342, 685, 343, 687, 344, 689, + 345, 691, 346, 693, 347, 695, 348, 697, 349, 699, 350, 701, 351, 703, 352, + 705, 353, 707, 354, 709, 355, 711, 356, 713, 357, 715, 358, 717, 359, 719, + 360, 721, 361, 723, 362, 725, 363, 727, 364, 729, 365, 731, 366, 733, 367, + 735, 368, 737, 369, 739, 370, 741, 371, 743, 372, 745, 373, 747, 374, 749, + 375, 751, 376, 753, 377, 755, 378, 757, 379, 759, 380, 761, 381, 763, 382, + 765, 383, 767, 384, 769, 385, 771, 386, 773, 387, 775, 388, 777, 389, 779, + 390, 781, 391, 783, 392, 785, 393, 787, 394, 789, 395, 791, 396, 793, 397, + 795, 398, 797, 399, 799, 400, 801, 401, 803, 402, 805, 403, 807, 404, 809, + 405, 811, 406, 813, 407, 815, 408, 817, 409, 819, 410, 821, 411, 823, 412, + 825, 413, 827, 414, 829, 415, 831, 416, 833, 417, 835, 418, 837, 419, 839, + 420, 841, 421, 843, 422, 845, 423, 847, 424, 849, 425, 851, 426, 853, 427, + 855, 428, 857, 429, 859, 430, 861, 431, 863, 432, 865, 433, 867, 434, 869, + 435, 871, 436, 873, 437, 875, 438, 877, 439, 879, 440, 881, 441, 883, 442, + 885, 443, 887, 444, 889, 445, 891, 446, 893, 447, 895, 448, 897, 449, 899, + 450, 901, 451, 903, 452, 905, 453, 907, 454, 909, 455, 911, 456, 913, 457, + 915, 458, 917, 459, 919, 460, 921, 461, 923, 462, 925, 463, 927, 464, 929, + 465, 931, 466, 933, 467, 935, 468, 937, 469, 939, 470, 941, 471, 943, 472, + 945, 473, 947, 474, 949, 475, 951, 476, 953, 477, 955, 478, 957, 479, 959, + 480, 961, 481, 963, 482, 965, 483, 967, 484, 969, 485, 971, 486, 973, 487, + 975, 488, 977, 489, 979, 490, 981, 491, 983, 492, 985, 493, 987, 494, 989, + 495, 991, 496, 993, 497, 995, 498, 997, 499, 999, 500, 1001, 501, 1003, + 502, 1005, 503, 1007, 504, 1009, 505, 1011, 506, 1013, 507, 1015, 508, + 1017, 509, 1019, 510, 1021, 511, 1023, 512, 1025, 513, 1027, 514, 1029, + 515, 1031, 516, 1033, 517, 1035, 518, 1037, 519, 1039, 520, 1041, 521, + 1043, 522, 1045, 523, 1047, 524, 1049, 525, 1051, 526, 1053, 527, 1055, + 528, 1057, 529, 1059, 530, 1061, 531, 1063, 532, 1065, 533, 1067, 534, + 1069, 535, 1071, 536, 1073, 537, 1075, 538, 1077, 539, 1079, 540, 1081, + 541, 1083, 542, 1085, 543, 1087, 544, 1089, 545, 1091, 546, 1093, 547, + 1095, 548, 1097, 549, 1099, 550, 1101, 551, 1103, 552, 1105, 553, 1107, + 554, 1109, 555, 1111, 556, 1113, 557, 1115, 558, 1117, 559, 1119, 560, + 1121, 561, 1123, 562, 1125, 563, 1127, 564, 1129, 565, 1131, 566, 1133, + 567, 1135, 568, 1137, 569, 1139, 570, 1141, 571, 1143, 572, 1145, 573, + 1147, 574, 1149, 575, 1151, 576, 1153, 577, 1155, 578, 1157, 579, 1159, + 580, 1161, 581, 1163, 582, 1165, 583, 1167, 584, 1169, 585, 1171, 586, + 1173, 587, 1175, 588, 1177, 589, 1179, 590, 1181, 591, 1183, 592, 1185, + 593, 1187, 594, 1189, 595, 1191, 596, 1193, 597, 1195, 598, 1197, 599, + 1199, 600, 1201, 601, 1203, 602, 1205, 603, 1207, 604, 1209, 605, 1211, + 606, 1213, 607, 1215, 608, 1217, 609, 1219, 610, 1221, 611, 1223, 612, + 1225, 613, 1227, 614, 1229, 615, 1231, 616, 1233, 617, 1235, 618, 1237, + 619, 1239, 620, 1241, 621, 1243, 622, 1245, 623, 1247, 624, 1249, 625, + 1251, 626, 1253, 627, 1255, 628, 1257, 629, 1259, 630, 1261, 631, 1263, + 632, 1265, 633, 1267, 634, 1269, 635, 1271, 636, 1273, 637, 1275, 638, + 1277, 639, 1279, 640, 1281, 641, 1283, 642, 1285, 643, 1287, 644, 1289, + 645, 1291, 646, 1293, 647, 1295, 648, 1297, 649, 1299, 650, 1301, 651, + 1303, 652, 1305, 653, 1307, 654, 1309, 655, 1311, 656, 1313, 657, 1315, + 658, 1317, 659, 1319, 660, 1321, 661, 1323, 662, 1325, 663, 1327, 664, + 1329, 665, 1331, 666, 1333, 667, 1335, 668, 1337, 669, 1339, 670, 1341, + 671, 1343, 672, 1345, 673, 1347, 674, 1349, 675, 1351, 676, 1353, 677, + 1355, 678, 1357, 679, 1359, 680, 1361, 681, 1363, 682, 1365, 683, 1367, + 684, 1369, 685, 1371, 686, 1373, 687, 1375, 688, 1377, 689, 1379, 690, + 1381, 691, 1383, 692, 1385, 693, 1387, 694, 1389, 695, 1391, 696, 1393, + 697, 1395, 698, 1397, 699, 1399, 700, 1401, 701, 1403, 702, 1405, 703, + 1407, 704, 1409, 705, 1411, 706, 1413, 707, 1415, 708, 1417, 709, 1419, + 710, 1421, 711, 1423, 712, 1425, 713, 1427, 714, 1429, 715, 1431, 716, + 1433, 717, 1435, 718, 1437, 719, 1439, 720, 1441, 721, 1443, 722, 1445, + 723, 1447, 724, 1449, 725, 1451, 726, 1453, 727, 1455, 728, 1457, 729, + 1459, 730, 1461, 731, 1463, 732, 1465, 733, 1467, 734, 1469, 735, 1471, + 736, 1473, 737, 1475, 738, 1477, 739, 1479, 740, 1481, 741, 1483, 742, + 1485, 743, 1487, 744, 1489, 745, 1491, 746, 1493, 747, 1495, 748, 1497, + 749, 1499, 750, 1501, 751, 1503, 752, 1505, 753, 1507, 754, 1509, 755, + 1511, 756, 1513, 757, 1515, 758, 1517, 759, 1519, 760, 1521, 761, 1523, + 762, 1525, 763, 1527, 764, 1529, 765, 1531, 766, 1533, 767, 1535, 768, + 1537, 769, 1539, 770, 1541, 771, 1543, 772, 1545, 773, 1547, 774, 1549, + 775, 1551, 776, 1553, 777, 1555, 778, 1557, 779, 1559, 780, 1561, 781, + 1563, 782, 1565, 783, 1567, 784, 1569, 785, 1571, 786, 1573, 787, 1575, + 788, 1577, 789, 1579, 790, 1581, 791, 1583, 792, 1585, 793, 1587, 794, + 1589, 795, 1591, 796, 1593, 797, 1595, 798, 1597, 799, 1599, 800, 1601, + 801, 1603, 802, 1605, 803, 1607, 804, 1609, 805, 1611, 806, 1613, 807, + 1615, 808, 1617, 809, 1619, 810, 1621, 811, 1623, 812, 1625, 813, 1627, + 814, 1629, 815, 1631, 816, 1633, 817, 1635, 818, 1637, 819, 1639, 820, + 1641, 821, 1643, 822, 1645, 823, 1647, 824, 1649, 825, 1651, 826, 1653, + 827, 1655, 828, 1657, 829, 1659, 830, 1661, 831, 1663, 832, 1665, 833, + 1667, 834, 1669, 835, 1671, 836, 1673, 837, 1675, 838, 1677, 839, 1679, + 840, 1681, 841, 1683, 842, 1685, 843, 1687, 844, 1689, 845, 1691, 846, + 1693, 847, 1695, 848, 1697, 849, 1699, 850, 1701, 851, 1703, 852, 1705, + 853, 1707, 854, 1709, 855, 1711, 856, 1713, 857, 1715, 858, 1717, 859, + 1719, 860, 1721, 861, 1723, 862, 1725, 863, 1727, 864, 1729, 865, 1731, + 866, 1733, 867, 1735, 868, 1737, 869, 1739, 870, 1741, 871, 1743, 872, + 1745, 873, 1747, 874, 1749, 875, 1751, 876, 1753, 877, 1755, 878, 1757, + 879, 1759, 880, 1761, 881, 1763, 882, 1765, 883, 1767, 884, 1769, 885, + 1771, 886, 1773, 887, 1775, 888, 1777, 889, 1779, 890, 1781, 891, 1783, + 892, 1785, 893, 1787, 894, 1789, 895, 1791, 896, 1793, 897, 1795, 898, + 1797, 899, 1799, 900, 1801, 901, 1803, 902, 1805, 903, 1807, 904, 1809, + 905, 1811, 906, 1813, 907, 1815, 908, 1817, 909, 1819, 910, 1821, 911, + 1823, 912, 1825, 913, 1827, 914, 1829, 915, 1831, 916, 1833, 917, 1835, + 918, 1837, 919, 1839, 920, 1841, 921, 1843, 922, 1845, 923, 1847, 924, + 1849, 925, 1851, 926, 1853, 927, 1855, 928, 1857, 929, 1859, 930, 1861, + 931, 1863, 932, 1865, 933, 1867, 934, 1869, 935, 1871, 936, 1873, 937, + 1875, 938, 1877, 939, 1879, 940, 1881, 941, 1883, 942, 1885, 943, 1887, + 944, 1889, 945, 1891, 946, 1893, 947, 1895, 948, 1897, 949, 1899, 950, + 1901, 951, 1903, 952, 1905, 953, 1907, 954, 1909, 955, 1911, 956, 1913, + 957, 1915, 958, 1917, 959, 1919, 960, 1921, 961, 1923, 962, 1925, 963, + 1927, 964, 1929, 965, 1931, 966, 1933, 967, 1935, 968, 1937, 969, 1939, + 970, 1941, 971, 1943, 972, 1945, 973, 1947, 974, 1949, 975, 1951, 976, + 1953, 977, 1955, 978, 1957, 979, 1959, 980, 1961, 981, 1963, 982, 1965, + 983, 1967, 984, 1969, 985, 1971, 986, 1973, 987, 1975, 988, 1977, 989, + 1979, 990, 1981, 991, 1983, 992, 1985, 993, 1987, 994, 1989, 995, 1991, + 996, 1993, 997, 1995, 998, 1997, 999, 1999, 1000, 2001, 1001, 2003, 1002, + 2005, 1003, 2007, 1004, 2009, 1005, 2011, 1006, 2013, 1007, 2015, 1008, + 2017, 1009, 2019, 1010, 2021, 1011, 2023, 1012, 2025, 1013, 2027, 1014, + 2029, 1015, 2031, 1016, 2033, 1017, 2035, 1018, 2037, 1019, 2039, 1020, + 2041, 1021, 2043, 1022, 2045, 1023, 2047, 1024, 2049, 1025, 2051, 1026, + 2053, 1027, 2055, 1028, 2057, 1029, 2059, 1030, 2061, 1031, 2063, 1032, + 2065, 1033, 2067, 1034, 2069, 1035, 2071, 1036, 2073, 1037, 2075, 1038, + 2077, 1039, 2079, 1040, 2081, 1041, 2083, 1042, 2085, 1043, 2087, 1044, + 2089, 1045, 2091, 1046, 2093, 1047, 2095, 1048, 2097, 1049, 2099, 1050, + 2101, 1051, 2103, 1052, 2105, 1053, 2107, 1054, 2109, 1055, 2111, 1056, + 2113, 1057, 2115, 1058, 2117, 1059, 2119, 1060, 2121, 1061, 2123, 1062, + 2125, 1063, 2127, 1064, 2129, 1065, 2131, 1066, 2133, 1067, 2135, 1068, + 2137, 1069, 2139, 1070, 2141, 1071, 2143, 1072, 2145, 1073, 2147, 1074, + 2149, 1075, 2151, 1076, 2153, 1077, 2155, 1078, 2157, 1079, 2159, 1080, + 2161, 1081, 2163, 1082, 2165, 1083, 2167, 1084, 2169, 1085, 2171, 1086, + 2173, 1087, 2175, 1088, 2177, 1089, 2179, 1090, 2181, 1091, 2183, 1092, + 2185, 1093, 2187, 1094, 2189, 1095, 2191, 1096, 2193, 1097, 2195, 1098, + 2197, 1099, 2199, 1100, 2201, 1101, 2203, 1102, 2205, 1103, 2207, 1104, + 2209, 1105, 2211, 1106, 2213, 1107, 2215, 1108, 2217, 1109, 2219, 1110, + 2221, 1111, 2223, 1112, 2225, 1113, 2227, 1114, 2229, 1115, 2231, 1116, + 2233, 1117, 2235, 1118, 2237, 1119, 2239, 1120, 2241, 1121, 2243, 1122, + 2245, 1123, 2247, 1124, 2249, 1125, 2251, 1126, 2253, 1127, 2255, 1128, + 2257, 1129, 2259, 1130, 2261, 1131, 2263, 1132, 2265, 1133, 2267, 1134, + 2269, 1135, 2271, 1136, 2273, 1137, 2275, 1138, 2277, 1139, 2279, 1140, + 2281, 1141, 2283, 1142, 2285, 1143, 2287, 1144, 2289, 1145, 2291, 1146, + 2293, 1147, 2295, 1148, 2297, 1149, 2299, 0, 2301, 1150, 2303, 1151, 2305, + 1152, 2307, 1153, 2309, 1154, 2311, 1155, 2313, 1156, 2315, 1157, 2317, + 1158, 2319, 1159, 2321, 1160, 2323, 1161, 2325, 1162, 2327, 1163, 2329, + 1164, 2331, 1165, 2333, 0, 2335, 0, 2337, 0, 2339, 0, 2341, 0, 2343, 0, + 2345, 0, 2347, 0, 2349, 0, 2351, 0, 2353, 1166, 1, 0, 42, 3, 0, 9, 10, + 13, 13, 32, 32, 2, 0, 9, 9, 32, 32, 2, 0, 10, 10, 13, 13, 2, 0, 65, 65, + 97, 97, 2, 0, 68, 68, 100, 100, 2, 0, 76, 76, 108, 108, 2, 0, 84, 84, 116, + 116, 2, 0, 69, 69, 101, 101, 2, 0, 82, 82, 114, 114, 2, 0, 87, 87, 119, + 119, 2, 0, 89, 89, 121, 121, 2, 0, 83, 83, 115, 115, 2, 0, 78, 78, 110, + 110, 2, 0, 90, 90, 122, 122, 2, 0, 67, 67, 99, 99, 2, 0, 73, 73, 105, 105, + 2, 0, 66, 66, 98, 98, 2, 0, 85, 85, 117, 117, 2, 0, 70, 70, 102, 102, 2, + 0, 79, 79, 111, 111, 2, 0, 72, 72, 104, 104, 2, 0, 75, 75, 107, 107, 2, + 0, 71, 71, 103, 103, 2, 0, 77, 77, 109, 109, 2, 0, 86, 86, 118, 118, 2, + 0, 80, 80, 112, 112, 2, 0, 88, 88, 120, 120, 2, 0, 74, 74, 106, 106, 2, + 0, 81, 81, 113, 113, 8, 0, 71, 71, 75, 75, 77, 77, 84, 84, 103, 103, 107, + 107, 109, 109, 116, 116, 7, 0, 36, 36, 46, 46, 48, 57, 65, 90, 95, 95, + 97, 122, 128, 65535, 2, 0, 43, 43, 45, 45, 6, 0, 36, 36, 48, 57, 65, 90, + 95, 95, 97, 122, 128, 65535, 5, 0, 36, 36, 65, 90, 95, 95, 97, 122, 128, + 65535, 2, 0, 34, 34, 92, 92, 2, 0, 39, 39, 92, 92, 1, 0, 96, 96, 3, 0, + 48, 57, 65, 70, 97, 102, 1, 0, 48, 57, 1, 0, 48, 49, 2, 0, 46, 46, 48, + 57, 3, 0, 48, 58, 65, 70, 97, 102, 13857, 0, 1, 1, 0, 0, 0, 0, 3, 1, 0, + 0, 0, 0, 5, 1, 0, 0, 0, 0, 7, 1, 0, 0, 0, 0, 9, 1, 0, 0, 0, 0, 11, 1, 0, + 0, 0, 0, 13, 1, 0, 0, 0, 0, 15, 1, 0, 0, 0, 0, 17, 1, 0, 0, 0, 0, 19, 1, + 0, 0, 0, 0, 21, 1, 0, 0, 0, 0, 23, 1, 0, 0, 0, 0, 25, 1, 0, 0, 0, 0, 27, + 1, 0, 0, 0, 0, 29, 1, 0, 0, 0, 0, 31, 1, 0, 0, 0, 0, 33, 1, 0, 0, 0, 0, + 35, 1, 0, 0, 0, 0, 37, 1, 0, 0, 0, 0, 39, 1, 0, 0, 0, 0, 41, 1, 0, 0, 0, + 0, 43, 1, 0, 0, 0, 0, 45, 1, 0, 0, 0, 0, 47, 1, 0, 0, 0, 0, 49, 1, 0, 0, + 0, 0, 51, 1, 0, 0, 0, 0, 53, 1, 0, 0, 0, 0, 55, 1, 0, 0, 0, 0, 57, 1, 0, + 0, 0, 0, 59, 1, 0, 0, 0, 0, 61, 1, 0, 0, 0, 0, 63, 1, 0, 0, 0, 0, 65, 1, + 0, 0, 0, 0, 67, 1, 0, 0, 0, 0, 69, 1, 0, 0, 0, 0, 71, 1, 0, 0, 0, 0, 73, + 1, 0, 0, 0, 0, 75, 1, 0, 0, 0, 0, 77, 1, 0, 0, 0, 0, 79, 1, 0, 0, 0, 0, + 81, 1, 0, 0, 0, 0, 83, 1, 0, 0, 0, 0, 85, 1, 0, 0, 0, 0, 87, 1, 0, 0, 0, + 0, 89, 1, 0, 0, 0, 0, 91, 1, 0, 0, 0, 0, 93, 1, 0, 0, 0, 0, 95, 1, 0, 0, + 0, 0, 97, 1, 0, 0, 0, 0, 99, 1, 0, 0, 0, 0, 101, 1, 0, 0, 0, 0, 103, 1, + 0, 0, 0, 0, 105, 1, 0, 0, 0, 0, 107, 1, 0, 0, 0, 0, 109, 1, 0, 0, 0, 0, + 111, 1, 0, 0, 0, 0, 113, 1, 0, 0, 0, 0, 115, 1, 0, 0, 0, 0, 117, 1, 0, + 0, 0, 0, 119, 1, 0, 0, 0, 0, 121, 1, 0, 0, 0, 0, 123, 1, 0, 0, 0, 0, 125, + 1, 0, 0, 0, 0, 127, 1, 0, 0, 0, 0, 129, 1, 0, 0, 0, 0, 131, 1, 0, 0, 0, + 0, 133, 1, 0, 0, 0, 0, 135, 1, 0, 0, 0, 0, 137, 1, 0, 0, 0, 0, 139, 1, + 0, 0, 0, 0, 141, 1, 0, 0, 0, 0, 143, 1, 0, 0, 0, 0, 145, 1, 0, 0, 0, 0, + 147, 1, 0, 0, 0, 0, 149, 1, 0, 0, 0, 0, 151, 1, 0, 0, 0, 0, 153, 1, 0, + 0, 0, 0, 155, 1, 0, 0, 0, 0, 157, 1, 0, 0, 0, 0, 159, 1, 0, 0, 0, 0, 161, + 1, 0, 0, 0, 0, 163, 1, 0, 0, 0, 0, 165, 1, 0, 0, 0, 0, 167, 1, 0, 0, 0, + 0, 169, 1, 0, 0, 0, 0, 171, 1, 0, 0, 0, 0, 173, 1, 0, 0, 0, 0, 175, 1, + 0, 0, 0, 0, 177, 1, 0, 0, 0, 0, 179, 1, 0, 0, 0, 0, 181, 1, 0, 0, 0, 0, + 183, 1, 0, 0, 0, 0, 185, 1, 0, 0, 0, 0, 187, 1, 0, 0, 0, 0, 189, 1, 0, + 0, 0, 0, 191, 1, 0, 0, 0, 0, 193, 1, 0, 0, 0, 0, 195, 1, 0, 0, 0, 0, 197, + 1, 0, 0, 0, 0, 199, 1, 0, 0, 0, 0, 201, 1, 0, 0, 0, 0, 203, 1, 0, 0, 0, + 0, 205, 1, 0, 0, 0, 0, 207, 1, 0, 0, 0, 0, 209, 1, 0, 0, 0, 0, 211, 1, + 0, 0, 0, 0, 213, 1, 0, 0, 0, 0, 215, 1, 0, 0, 0, 0, 217, 1, 0, 0, 0, 0, + 219, 1, 0, 0, 0, 0, 221, 1, 0, 0, 0, 0, 223, 1, 0, 0, 0, 0, 225, 1, 0, + 0, 0, 0, 227, 1, 0, 0, 0, 0, 229, 1, 0, 0, 0, 0, 231, 1, 0, 0, 0, 0, 233, + 1, 0, 0, 0, 0, 235, 1, 0, 0, 0, 0, 237, 1, 0, 0, 0, 0, 239, 1, 0, 0, 0, + 0, 241, 1, 0, 0, 0, 0, 243, 1, 0, 0, 0, 0, 245, 1, 0, 0, 0, 0, 247, 1, + 0, 0, 0, 0, 249, 1, 0, 0, 0, 0, 251, 1, 0, 0, 0, 0, 253, 1, 0, 0, 0, 0, + 255, 1, 0, 0, 0, 0, 257, 1, 0, 0, 0, 0, 259, 1, 0, 0, 0, 0, 261, 1, 0, + 0, 0, 0, 263, 1, 0, 0, 0, 0, 265, 1, 0, 0, 0, 0, 267, 1, 0, 0, 0, 0, 269, + 1, 0, 0, 0, 0, 271, 1, 0, 0, 0, 0, 273, 1, 0, 0, 0, 0, 275, 1, 0, 0, 0, + 0, 277, 1, 0, 0, 0, 0, 279, 1, 0, 0, 0, 0, 281, 1, 0, 0, 0, 0, 283, 1, + 0, 0, 0, 0, 285, 1, 0, 0, 0, 0, 287, 1, 0, 0, 0, 0, 289, 1, 0, 0, 0, 0, + 291, 1, 0, 0, 0, 0, 293, 1, 0, 0, 0, 0, 295, 1, 0, 0, 0, 0, 297, 1, 0, + 0, 0, 0, 299, 1, 0, 0, 0, 0, 301, 1, 0, 0, 0, 0, 303, 1, 0, 0, 0, 0, 305, + 1, 0, 0, 0, 0, 307, 1, 0, 0, 0, 0, 309, 1, 0, 0, 0, 0, 311, 1, 0, 0, 0, + 0, 313, 1, 0, 0, 0, 0, 315, 1, 0, 0, 0, 0, 317, 1, 0, 0, 0, 0, 319, 1, + 0, 0, 0, 0, 321, 1, 0, 0, 0, 0, 323, 1, 0, 0, 0, 0, 325, 1, 0, 0, 0, 0, + 327, 1, 0, 0, 0, 0, 329, 1, 0, 0, 0, 0, 331, 1, 0, 0, 0, 0, 333, 1, 0, + 0, 0, 0, 335, 1, 0, 0, 0, 0, 337, 1, 0, 0, 0, 0, 339, 1, 0, 0, 0, 0, 341, + 1, 0, 0, 0, 0, 343, 1, 0, 0, 0, 0, 345, 1, 0, 0, 0, 0, 347, 1, 0, 0, 0, + 0, 349, 1, 0, 0, 0, 0, 351, 1, 0, 0, 0, 0, 353, 1, 0, 0, 0, 0, 355, 1, + 0, 0, 0, 0, 357, 1, 0, 0, 0, 0, 359, 1, 0, 0, 0, 0, 361, 1, 0, 0, 0, 0, + 363, 1, 0, 0, 0, 0, 365, 1, 0, 0, 0, 0, 367, 1, 0, 0, 0, 0, 369, 1, 0, + 0, 0, 0, 371, 1, 0, 0, 0, 0, 373, 1, 0, 0, 0, 0, 375, 1, 0, 0, 0, 0, 377, + 1, 0, 0, 0, 0, 379, 1, 0, 0, 0, 0, 381, 1, 0, 0, 0, 0, 383, 1, 0, 0, 0, + 0, 385, 1, 0, 0, 0, 0, 387, 1, 0, 0, 0, 0, 389, 1, 0, 0, 0, 0, 391, 1, + 0, 0, 0, 0, 393, 1, 0, 0, 0, 0, 395, 1, 0, 0, 0, 0, 397, 1, 0, 0, 0, 0, + 399, 1, 0, 0, 0, 0, 401, 1, 0, 0, 0, 0, 403, 1, 0, 0, 0, 0, 405, 1, 0, + 0, 0, 0, 407, 1, 0, 0, 0, 0, 409, 1, 0, 0, 0, 0, 411, 1, 0, 0, 0, 0, 413, + 1, 0, 0, 0, 0, 415, 1, 0, 0, 0, 0, 417, 1, 0, 0, 0, 0, 419, 1, 0, 0, 0, + 0, 421, 1, 0, 0, 0, 0, 423, 1, 0, 0, 0, 0, 425, 1, 0, 0, 0, 0, 427, 1, + 0, 0, 0, 0, 429, 1, 0, 0, 0, 0, 431, 1, 0, 0, 0, 0, 433, 1, 0, 0, 0, 0, + 435, 1, 0, 0, 0, 0, 437, 1, 0, 0, 0, 0, 439, 1, 0, 0, 0, 0, 441, 1, 0, + 0, 0, 0, 443, 1, 0, 0, 0, 0, 445, 1, 0, 0, 0, 0, 447, 1, 0, 0, 0, 0, 449, + 1, 0, 0, 0, 0, 451, 1, 0, 0, 0, 0, 453, 1, 0, 0, 0, 0, 455, 1, 0, 0, 0, + 0, 457, 1, 0, 0, 0, 0, 459, 1, 0, 0, 0, 0, 461, 1, 0, 0, 0, 0, 463, 1, + 0, 0, 0, 0, 465, 1, 0, 0, 0, 0, 467, 1, 0, 0, 0, 0, 469, 1, 0, 0, 0, 0, + 471, 1, 0, 0, 0, 0, 473, 1, 0, 0, 0, 0, 475, 1, 0, 0, 0, 0, 477, 1, 0, + 0, 0, 0, 479, 1, 0, 0, 0, 0, 481, 1, 0, 0, 0, 0, 483, 1, 0, 0, 0, 0, 485, + 1, 0, 0, 0, 0, 487, 1, 0, 0, 0, 0, 489, 1, 0, 0, 0, 0, 491, 1, 0, 0, 0, + 0, 493, 1, 0, 0, 0, 0, 495, 1, 0, 0, 0, 0, 497, 1, 0, 0, 0, 0, 499, 1, + 0, 0, 0, 0, 501, 1, 0, 0, 0, 0, 503, 1, 0, 0, 0, 0, 505, 1, 0, 0, 0, 0, + 507, 1, 0, 0, 0, 0, 509, 1, 0, 0, 0, 0, 511, 1, 0, 0, 0, 0, 513, 1, 0, + 0, 0, 0, 515, 1, 0, 0, 0, 0, 517, 1, 0, 0, 0, 0, 519, 1, 0, 0, 0, 0, 521, + 1, 0, 0, 0, 0, 523, 1, 0, 0, 0, 0, 525, 1, 0, 0, 0, 0, 527, 1, 0, 0, 0, + 0, 529, 1, 0, 0, 0, 0, 531, 1, 0, 0, 0, 0, 533, 1, 0, 0, 0, 0, 535, 1, + 0, 0, 0, 0, 537, 1, 0, 0, 0, 0, 539, 1, 0, 0, 0, 0, 541, 1, 0, 0, 0, 0, + 543, 1, 0, 0, 0, 0, 545, 1, 0, 0, 0, 0, 547, 1, 0, 0, 0, 0, 549, 1, 0, + 0, 0, 0, 551, 1, 0, 0, 0, 0, 553, 1, 0, 0, 0, 0, 555, 1, 0, 0, 0, 0, 557, + 1, 0, 0, 0, 0, 559, 1, 0, 0, 0, 0, 561, 1, 0, 0, 0, 0, 563, 1, 0, 0, 0, + 0, 565, 1, 0, 0, 0, 0, 567, 1, 0, 0, 0, 0, 569, 1, 0, 0, 0, 0, 571, 1, + 0, 0, 0, 0, 573, 1, 0, 0, 0, 0, 575, 1, 0, 0, 0, 0, 577, 1, 0, 0, 0, 0, + 579, 1, 0, 0, 0, 0, 581, 1, 0, 0, 0, 0, 583, 1, 0, 0, 0, 0, 585, 1, 0, + 0, 0, 0, 587, 1, 0, 0, 0, 0, 589, 1, 0, 0, 0, 0, 591, 1, 0, 0, 0, 0, 593, + 1, 0, 0, 0, 0, 595, 1, 0, 0, 0, 0, 597, 1, 0, 0, 0, 0, 599, 1, 0, 0, 0, + 0, 601, 1, 0, 0, 0, 0, 603, 1, 0, 0, 0, 0, 605, 1, 0, 0, 0, 0, 607, 1, + 0, 0, 0, 0, 609, 1, 0, 0, 0, 0, 611, 1, 0, 0, 0, 0, 613, 1, 0, 0, 0, 0, + 615, 1, 0, 0, 0, 0, 617, 1, 0, 0, 0, 0, 619, 1, 0, 0, 0, 0, 621, 1, 0, + 0, 0, 0, 623, 1, 0, 0, 0, 0, 625, 1, 0, 0, 0, 0, 627, 1, 0, 0, 0, 0, 629, + 1, 0, 0, 0, 0, 631, 1, 0, 0, 0, 0, 633, 1, 0, 0, 0, 0, 635, 1, 0, 0, 0, + 0, 637, 1, 0, 0, 0, 0, 639, 1, 0, 0, 0, 0, 641, 1, 0, 0, 0, 0, 643, 1, + 0, 0, 0, 0, 645, 1, 0, 0, 0, 0, 647, 1, 0, 0, 0, 0, 649, 1, 0, 0, 0, 0, + 651, 1, 0, 0, 0, 0, 653, 1, 0, 0, 0, 0, 655, 1, 0, 0, 0, 0, 657, 1, 0, + 0, 0, 0, 659, 1, 0, 0, 0, 0, 661, 1, 0, 0, 0, 0, 663, 1, 0, 0, 0, 0, 665, + 1, 0, 0, 0, 0, 667, 1, 0, 0, 0, 0, 669, 1, 0, 0, 0, 0, 671, 1, 0, 0, 0, + 0, 673, 1, 0, 0, 0, 0, 675, 1, 0, 0, 0, 0, 677, 1, 0, 0, 0, 0, 679, 1, + 0, 0, 0, 0, 681, 1, 0, 0, 0, 0, 683, 1, 0, 0, 0, 0, 685, 1, 0, 0, 0, 0, + 687, 1, 0, 0, 0, 0, 689, 1, 0, 0, 0, 0, 691, 1, 0, 0, 0, 0, 693, 1, 0, + 0, 0, 0, 695, 1, 0, 0, 0, 0, 697, 1, 0, 0, 0, 0, 699, 1, 0, 0, 0, 0, 701, + 1, 0, 0, 0, 0, 703, 1, 0, 0, 0, 0, 705, 1, 0, 0, 0, 0, 707, 1, 0, 0, 0, + 0, 709, 1, 0, 0, 0, 0, 711, 1, 0, 0, 0, 0, 713, 1, 0, 0, 0, 0, 715, 1, + 0, 0, 0, 0, 717, 1, 0, 0, 0, 0, 719, 1, 0, 0, 0, 0, 721, 1, 0, 0, 0, 0, + 723, 1, 0, 0, 0, 0, 725, 1, 0, 0, 0, 0, 727, 1, 0, 0, 0, 0, 729, 1, 0, + 0, 0, 0, 731, 1, 0, 0, 0, 0, 733, 1, 0, 0, 0, 0, 735, 1, 0, 0, 0, 0, 737, + 1, 0, 0, 0, 0, 739, 1, 0, 0, 0, 0, 741, 1, 0, 0, 0, 0, 743, 1, 0, 0, 0, + 0, 745, 1, 0, 0, 0, 0, 747, 1, 0, 0, 0, 0, 749, 1, 0, 0, 0, 0, 751, 1, + 0, 0, 0, 0, 753, 1, 0, 0, 0, 0, 755, 1, 0, 0, 0, 0, 757, 1, 0, 0, 0, 0, + 759, 1, 0, 0, 0, 0, 761, 1, 0, 0, 0, 0, 763, 1, 0, 0, 0, 0, 765, 1, 0, + 0, 0, 0, 767, 1, 0, 0, 0, 0, 769, 1, 0, 0, 0, 0, 771, 1, 0, 0, 0, 0, 773, + 1, 0, 0, 0, 0, 775, 1, 0, 0, 0, 0, 777, 1, 0, 0, 0, 0, 779, 1, 0, 0, 0, + 0, 781, 1, 0, 0, 0, 0, 783, 1, 0, 0, 0, 0, 785, 1, 0, 0, 0, 0, 787, 1, + 0, 0, 0, 0, 789, 1, 0, 0, 0, 0, 791, 1, 0, 0, 0, 0, 793, 1, 0, 0, 0, 0, + 795, 1, 0, 0, 0, 0, 797, 1, 0, 0, 0, 0, 799, 1, 0, 0, 0, 0, 801, 1, 0, + 0, 0, 0, 803, 1, 0, 0, 0, 0, 805, 1, 0, 0, 0, 0, 807, 1, 0, 0, 0, 0, 809, + 1, 0, 0, 0, 0, 811, 1, 0, 0, 0, 0, 813, 1, 0, 0, 0, 0, 815, 1, 0, 0, 0, + 0, 817, 1, 0, 0, 0, 0, 819, 1, 0, 0, 0, 0, 821, 1, 0, 0, 0, 0, 823, 1, + 0, 0, 0, 0, 825, 1, 0, 0, 0, 0, 827, 1, 0, 0, 0, 0, 829, 1, 0, 0, 0, 0, + 831, 1, 0, 0, 0, 0, 833, 1, 0, 0, 0, 0, 835, 1, 0, 0, 0, 0, 837, 1, 0, + 0, 0, 0, 839, 1, 0, 0, 0, 0, 841, 1, 0, 0, 0, 0, 843, 1, 0, 0, 0, 0, 845, + 1, 0, 0, 0, 0, 847, 1, 0, 0, 0, 0, 849, 1, 0, 0, 0, 0, 851, 1, 0, 0, 0, + 0, 853, 1, 0, 0, 0, 0, 855, 1, 0, 0, 0, 0, 857, 1, 0, 0, 0, 0, 859, 1, + 0, 0, 0, 0, 861, 1, 0, 0, 0, 0, 863, 1, 0, 0, 0, 0, 865, 1, 0, 0, 0, 0, + 867, 1, 0, 0, 0, 0, 869, 1, 0, 0, 0, 0, 871, 1, 0, 0, 0, 0, 873, 1, 0, + 0, 0, 0, 875, 1, 0, 0, 0, 0, 877, 1, 0, 0, 0, 0, 879, 1, 0, 0, 0, 0, 881, + 1, 0, 0, 0, 0, 883, 1, 0, 0, 0, 0, 885, 1, 0, 0, 0, 0, 887, 1, 0, 0, 0, + 0, 889, 1, 0, 0, 0, 0, 891, 1, 0, 0, 0, 0, 893, 1, 0, 0, 0, 0, 895, 1, + 0, 0, 0, 0, 897, 1, 0, 0, 0, 0, 899, 1, 0, 0, 0, 0, 901, 1, 0, 0, 0, 0, + 903, 1, 0, 0, 0, 0, 905, 1, 0, 0, 0, 0, 907, 1, 0, 0, 0, 0, 909, 1, 0, + 0, 0, 0, 911, 1, 0, 0, 0, 0, 913, 1, 0, 0, 0, 0, 915, 1, 0, 0, 0, 0, 917, + 1, 0, 0, 0, 0, 919, 1, 0, 0, 0, 0, 921, 1, 0, 0, 0, 0, 923, 1, 0, 0, 0, + 0, 925, 1, 0, 0, 0, 0, 927, 1, 0, 0, 0, 0, 929, 1, 0, 0, 0, 0, 931, 1, + 0, 0, 0, 0, 933, 1, 0, 0, 0, 0, 935, 1, 0, 0, 0, 0, 937, 1, 0, 0, 0, 0, + 939, 1, 0, 0, 0, 0, 941, 1, 0, 0, 0, 0, 943, 1, 0, 0, 0, 0, 945, 1, 0, + 0, 0, 0, 947, 1, 0, 0, 0, 0, 949, 1, 0, 0, 0, 0, 951, 1, 0, 0, 0, 0, 953, + 1, 0, 0, 0, 0, 955, 1, 0, 0, 0, 0, 957, 1, 0, 0, 0, 0, 959, 1, 0, 0, 0, + 0, 961, 1, 0, 0, 0, 0, 963, 1, 0, 0, 0, 0, 965, 1, 0, 0, 0, 0, 967, 1, + 0, 0, 0, 0, 969, 1, 0, 0, 0, 0, 971, 1, 0, 0, 0, 0, 973, 1, 0, 0, 0, 0, + 975, 1, 0, 0, 0, 0, 977, 1, 0, 0, 0, 0, 979, 1, 0, 0, 0, 0, 981, 1, 0, + 0, 0, 0, 983, 1, 0, 0, 0, 0, 985, 1, 0, 0, 0, 0, 987, 1, 0, 0, 0, 0, 989, + 1, 0, 0, 0, 0, 991, 1, 0, 0, 0, 0, 993, 1, 0, 0, 0, 0, 995, 1, 0, 0, 0, + 0, 997, 1, 0, 0, 0, 0, 999, 1, 0, 0, 0, 0, 1001, 1, 0, 0, 0, 0, 1003, 1, + 0, 0, 0, 0, 1005, 1, 0, 0, 0, 0, 1007, 1, 0, 0, 0, 0, 1009, 1, 0, 0, 0, + 0, 1011, 1, 0, 0, 0, 0, 1013, 1, 0, 0, 0, 0, 1015, 1, 0, 0, 0, 0, 1017, + 1, 0, 0, 0, 0, 1019, 1, 0, 0, 0, 0, 1021, 1, 0, 0, 0, 0, 1023, 1, 0, 0, + 0, 0, 1025, 1, 0, 0, 0, 0, 1027, 1, 0, 0, 0, 0, 1029, 1, 0, 0, 0, 0, 1031, + 1, 0, 0, 0, 0, 1033, 1, 0, 0, 0, 0, 1035, 1, 0, 0, 0, 0, 1037, 1, 0, 0, + 0, 0, 1039, 1, 0, 0, 0, 0, 1041, 1, 0, 0, 0, 0, 1043, 1, 0, 0, 0, 0, 1045, + 1, 0, 0, 0, 0, 1047, 1, 0, 0, 0, 0, 1049, 1, 0, 0, 0, 0, 1051, 1, 0, 0, + 0, 0, 1053, 1, 0, 0, 0, 0, 1055, 1, 0, 0, 0, 0, 1057, 1, 0, 0, 0, 0, 1059, + 1, 0, 0, 0, 0, 1061, 1, 0, 0, 0, 0, 1063, 1, 0, 0, 0, 0, 1065, 1, 0, 0, + 0, 0, 1067, 1, 0, 0, 0, 0, 1069, 1, 0, 0, 0, 0, 1071, 1, 0, 0, 0, 0, 1073, + 1, 0, 0, 0, 0, 1075, 1, 0, 0, 0, 0, 1077, 1, 0, 0, 0, 0, 1079, 1, 0, 0, + 0, 0, 1081, 1, 0, 0, 0, 0, 1083, 1, 0, 0, 0, 0, 1085, 1, 0, 0, 0, 0, 1087, + 1, 0, 0, 0, 0, 1089, 1, 0, 0, 0, 0, 1091, 1, 0, 0, 0, 0, 1093, 1, 0, 0, + 0, 0, 1095, 1, 0, 0, 0, 0, 1097, 1, 0, 0, 0, 0, 1099, 1, 0, 0, 0, 0, 1101, + 1, 0, 0, 0, 0, 1103, 1, 0, 0, 0, 0, 1105, 1, 0, 0, 0, 0, 1107, 1, 0, 0, + 0, 0, 1109, 1, 0, 0, 0, 0, 1111, 1, 0, 0, 0, 0, 1113, 1, 0, 0, 0, 0, 1115, + 1, 0, 0, 0, 0, 1117, 1, 0, 0, 0, 0, 1119, 1, 0, 0, 0, 0, 1121, 1, 0, 0, + 0, 0, 1123, 1, 0, 0, 0, 0, 1125, 1, 0, 0, 0, 0, 1127, 1, 0, 0, 0, 0, 1129, + 1, 0, 0, 0, 0, 1131, 1, 0, 0, 0, 0, 1133, 1, 0, 0, 0, 0, 1135, 1, 0, 0, + 0, 0, 1137, 1, 0, 0, 0, 0, 1139, 1, 0, 0, 0, 0, 1141, 1, 0, 0, 0, 0, 1143, + 1, 0, 0, 0, 0, 1145, 1, 0, 0, 0, 0, 1147, 1, 0, 0, 0, 0, 1149, 1, 0, 0, + 0, 0, 1151, 1, 0, 0, 0, 0, 1153, 1, 0, 0, 0, 0, 1155, 1, 0, 0, 0, 0, 1157, + 1, 0, 0, 0, 0, 1159, 1, 0, 0, 0, 0, 1161, 1, 0, 0, 0, 0, 1163, 1, 0, 0, + 0, 0, 1165, 1, 0, 0, 0, 0, 1167, 1, 0, 0, 0, 0, 1169, 1, 0, 0, 0, 0, 1171, + 1, 0, 0, 0, 0, 1173, 1, 0, 0, 0, 0, 1175, 1, 0, 0, 0, 0, 1177, 1, 0, 0, + 0, 0, 1179, 1, 0, 0, 0, 0, 1181, 1, 0, 0, 0, 0, 1183, 1, 0, 0, 0, 0, 1185, + 1, 0, 0, 0, 0, 1187, 1, 0, 0, 0, 0, 1189, 1, 0, 0, 0, 0, 1191, 1, 0, 0, + 0, 0, 1193, 1, 0, 0, 0, 0, 1195, 1, 0, 0, 0, 0, 1197, 1, 0, 0, 0, 0, 1199, + 1, 0, 0, 0, 0, 1201, 1, 0, 0, 0, 0, 1203, 1, 0, 0, 0, 0, 1205, 1, 0, 0, + 0, 0, 1207, 1, 0, 0, 0, 0, 1209, 1, 0, 0, 0, 0, 1211, 1, 0, 0, 0, 0, 1213, + 1, 0, 0, 0, 0, 1215, 1, 0, 0, 0, 0, 1217, 1, 0, 0, 0, 0, 1219, 1, 0, 0, + 0, 0, 1221, 1, 0, 0, 0, 0, 1223, 1, 0, 0, 0, 0, 1225, 1, 0, 0, 0, 0, 1227, + 1, 0, 0, 0, 0, 1229, 1, 0, 0, 0, 0, 1231, 1, 0, 0, 0, 0, 1233, 1, 0, 0, + 0, 0, 1235, 1, 0, 0, 0, 0, 1237, 1, 0, 0, 0, 0, 1239, 1, 0, 0, 0, 0, 1241, + 1, 0, 0, 0, 0, 1243, 1, 0, 0, 0, 0, 1245, 1, 0, 0, 0, 0, 1247, 1, 0, 0, + 0, 0, 1249, 1, 0, 0, 0, 0, 1251, 1, 0, 0, 0, 0, 1253, 1, 0, 0, 0, 0, 1255, + 1, 0, 0, 0, 0, 1257, 1, 0, 0, 0, 0, 1259, 1, 0, 0, 0, 0, 1261, 1, 0, 0, + 0, 0, 1263, 1, 0, 0, 0, 0, 1265, 1, 0, 0, 0, 0, 1267, 1, 0, 0, 0, 0, 1269, + 1, 0, 0, 0, 0, 1271, 1, 0, 0, 0, 0, 1273, 1, 0, 0, 0, 0, 1275, 1, 0, 0, + 0, 0, 1277, 1, 0, 0, 0, 0, 1279, 1, 0, 0, 0, 0, 1281, 1, 0, 0, 0, 0, 1283, + 1, 0, 0, 0, 0, 1285, 1, 0, 0, 0, 0, 1287, 1, 0, 0, 0, 0, 1289, 1, 0, 0, + 0, 0, 1291, 1, 0, 0, 0, 0, 1293, 1, 0, 0, 0, 0, 1295, 1, 0, 0, 0, 0, 1297, + 1, 0, 0, 0, 0, 1299, 1, 0, 0, 0, 0, 1301, 1, 0, 0, 0, 0, 1303, 1, 0, 0, + 0, 0, 1305, 1, 0, 0, 0, 0, 1307, 1, 0, 0, 0, 0, 1309, 1, 0, 0, 0, 0, 1311, + 1, 0, 0, 0, 0, 1313, 1, 0, 0, 0, 0, 1315, 1, 0, 0, 0, 0, 1317, 1, 0, 0, + 0, 0, 1319, 1, 0, 0, 0, 0, 1321, 1, 0, 0, 0, 0, 1323, 1, 0, 0, 0, 0, 1325, + 1, 0, 0, 0, 0, 1327, 1, 0, 0, 0, 0, 1329, 1, 0, 0, 0, 0, 1331, 1, 0, 0, + 0, 0, 1333, 1, 0, 0, 0, 0, 1335, 1, 0, 0, 0, 0, 1337, 1, 0, 0, 0, 0, 1339, + 1, 0, 0, 0, 0, 1341, 1, 0, 0, 0, 0, 1343, 1, 0, 0, 0, 0, 1345, 1, 0, 0, + 0, 0, 1347, 1, 0, 0, 0, 0, 1349, 1, 0, 0, 0, 0, 1351, 1, 0, 0, 0, 0, 1353, + 1, 0, 0, 0, 0, 1355, 1, 0, 0, 0, 0, 1357, 1, 0, 0, 0, 0, 1359, 1, 0, 0, + 0, 0, 1361, 1, 0, 0, 0, 0, 1363, 1, 0, 0, 0, 0, 1365, 1, 0, 0, 0, 0, 1367, + 1, 0, 0, 0, 0, 1369, 1, 0, 0, 0, 0, 1371, 1, 0, 0, 0, 0, 1373, 1, 0, 0, + 0, 0, 1375, 1, 0, 0, 0, 0, 1377, 1, 0, 0, 0, 0, 1379, 1, 0, 0, 0, 0, 1381, + 1, 0, 0, 0, 0, 1383, 1, 0, 0, 0, 0, 1385, 1, 0, 0, 0, 0, 1387, 1, 0, 0, + 0, 0, 1389, 1, 0, 0, 0, 0, 1391, 1, 0, 0, 0, 0, 1393, 1, 0, 0, 0, 0, 1395, + 1, 0, 0, 0, 0, 1397, 1, 0, 0, 0, 0, 1399, 1, 0, 0, 0, 0, 1401, 1, 0, 0, + 0, 0, 1403, 1, 0, 0, 0, 0, 1405, 1, 0, 0, 0, 0, 1407, 1, 0, 0, 0, 0, 1409, + 1, 0, 0, 0, 0, 1411, 1, 0, 0, 0, 0, 1413, 1, 0, 0, 0, 0, 1415, 1, 0, 0, + 0, 0, 1417, 1, 0, 0, 0, 0, 1419, 1, 0, 0, 0, 0, 1421, 1, 0, 0, 0, 0, 1423, + 1, 0, 0, 0, 0, 1425, 1, 0, 0, 0, 0, 1427, 1, 0, 0, 0, 0, 1429, 1, 0, 0, + 0, 0, 1431, 1, 0, 0, 0, 0, 1433, 1, 0, 0, 0, 0, 1435, 1, 0, 0, 0, 0, 1437, + 1, 0, 0, 0, 0, 1439, 1, 0, 0, 0, 0, 1441, 1, 0, 0, 0, 0, 1443, 1, 0, 0, + 0, 0, 1445, 1, 0, 0, 0, 0, 1447, 1, 0, 0, 0, 0, 1449, 1, 0, 0, 0, 0, 1451, + 1, 0, 0, 0, 0, 1453, 1, 0, 0, 0, 0, 1455, 1, 0, 0, 0, 0, 1457, 1, 0, 0, + 0, 0, 1459, 1, 0, 0, 0, 0, 1461, 1, 0, 0, 0, 0, 1463, 1, 0, 0, 0, 0, 1465, + 1, 0, 0, 0, 0, 1467, 1, 0, 0, 0, 0, 1469, 1, 0, 0, 0, 0, 1471, 1, 0, 0, + 0, 0, 1473, 1, 0, 0, 0, 0, 1475, 1, 0, 0, 0, 0, 1477, 1, 0, 0, 0, 0, 1479, + 1, 0, 0, 0, 0, 1481, 1, 0, 0, 0, 0, 1483, 1, 0, 0, 0, 0, 1485, 1, 0, 0, + 0, 0, 1487, 1, 0, 0, 0, 0, 1489, 1, 0, 0, 0, 0, 1491, 1, 0, 0, 0, 0, 1493, + 1, 0, 0, 0, 0, 1495, 1, 0, 0, 0, 0, 1497, 1, 0, 0, 0, 0, 1499, 1, 0, 0, + 0, 0, 1501, 1, 0, 0, 0, 0, 1503, 1, 0, 0, 0, 0, 1505, 1, 0, 0, 0, 0, 1507, + 1, 0, 0, 0, 0, 1509, 1, 0, 0, 0, 0, 1511, 1, 0, 0, 0, 0, 1513, 1, 0, 0, + 0, 0, 1515, 1, 0, 0, 0, 0, 1517, 1, 0, 0, 0, 0, 1519, 1, 0, 0, 0, 0, 1521, + 1, 0, 0, 0, 0, 1523, 1, 0, 0, 0, 0, 1525, 1, 0, 0, 0, 0, 1527, 1, 0, 0, + 0, 0, 1529, 1, 0, 0, 0, 0, 1531, 1, 0, 0, 0, 0, 1533, 1, 0, 0, 0, 0, 1535, + 1, 0, 0, 0, 0, 1537, 1, 0, 0, 0, 0, 1539, 1, 0, 0, 0, 0, 1541, 1, 0, 0, + 0, 0, 1543, 1, 0, 0, 0, 0, 1545, 1, 0, 0, 0, 0, 1547, 1, 0, 0, 0, 0, 1549, + 1, 0, 0, 0, 0, 1551, 1, 0, 0, 0, 0, 1553, 1, 0, 0, 0, 0, 1555, 1, 0, 0, + 0, 0, 1557, 1, 0, 0, 0, 0, 1559, 1, 0, 0, 0, 0, 1561, 1, 0, 0, 0, 0, 1563, + 1, 0, 0, 0, 0, 1565, 1, 0, 0, 0, 0, 1567, 1, 0, 0, 0, 0, 1569, 1, 0, 0, + 0, 0, 1571, 1, 0, 0, 0, 0, 1573, 1, 0, 0, 0, 0, 1575, 1, 0, 0, 0, 0, 1577, + 1, 0, 0, 0, 0, 1579, 1, 0, 0, 0, 0, 1581, 1, 0, 0, 0, 0, 1583, 1, 0, 0, + 0, 0, 1585, 1, 0, 0, 0, 0, 1587, 1, 0, 0, 0, 0, 1589, 1, 0, 0, 0, 0, 1591, + 1, 0, 0, 0, 0, 1593, 1, 0, 0, 0, 0, 1595, 1, 0, 0, 0, 0, 1597, 1, 0, 0, + 0, 0, 1599, 1, 0, 0, 0, 0, 1601, 1, 0, 0, 0, 0, 1603, 1, 0, 0, 0, 0, 1605, + 1, 0, 0, 0, 0, 1607, 1, 0, 0, 0, 0, 1609, 1, 0, 0, 0, 0, 1611, 1, 0, 0, + 0, 0, 1613, 1, 0, 0, 0, 0, 1615, 1, 0, 0, 0, 0, 1617, 1, 0, 0, 0, 0, 1619, + 1, 0, 0, 0, 0, 1621, 1, 0, 0, 0, 0, 1623, 1, 0, 0, 0, 0, 1625, 1, 0, 0, + 0, 0, 1627, 1, 0, 0, 0, 0, 1629, 1, 0, 0, 0, 0, 1631, 1, 0, 0, 0, 0, 1633, + 1, 0, 0, 0, 0, 1635, 1, 0, 0, 0, 0, 1637, 1, 0, 0, 0, 0, 1639, 1, 0, 0, + 0, 0, 1641, 1, 0, 0, 0, 0, 1643, 1, 0, 0, 0, 0, 1645, 1, 0, 0, 0, 0, 1647, + 1, 0, 0, 0, 0, 1649, 1, 0, 0, 0, 0, 1651, 1, 0, 0, 0, 0, 1653, 1, 0, 0, + 0, 0, 1655, 1, 0, 0, 0, 0, 1657, 1, 0, 0, 0, 0, 1659, 1, 0, 0, 0, 0, 1661, + 1, 0, 0, 0, 0, 1663, 1, 0, 0, 0, 0, 1665, 1, 0, 0, 0, 0, 1667, 1, 0, 0, + 0, 0, 1669, 1, 0, 0, 0, 0, 1671, 1, 0, 0, 0, 0, 1673, 1, 0, 0, 0, 0, 1675, + 1, 0, 0, 0, 0, 1677, 1, 0, 0, 0, 0, 1679, 1, 0, 0, 0, 0, 1681, 1, 0, 0, + 0, 0, 1683, 1, 0, 0, 0, 0, 1685, 1, 0, 0, 0, 0, 1687, 1, 0, 0, 0, 0, 1689, + 1, 0, 0, 0, 0, 1691, 1, 0, 0, 0, 0, 1693, 1, 0, 0, 0, 0, 1695, 1, 0, 0, + 0, 0, 1697, 1, 0, 0, 0, 0, 1699, 1, 0, 0, 0, 0, 1701, 1, 0, 0, 0, 0, 1703, + 1, 0, 0, 0, 0, 1705, 1, 0, 0, 0, 0, 1707, 1, 0, 0, 0, 0, 1709, 1, 0, 0, + 0, 0, 1711, 1, 0, 0, 0, 0, 1713, 1, 0, 0, 0, 0, 1715, 1, 0, 0, 0, 0, 1717, + 1, 0, 0, 0, 0, 1719, 1, 0, 0, 0, 0, 1721, 1, 0, 0, 0, 0, 1723, 1, 0, 0, + 0, 0, 1725, 1, 0, 0, 0, 0, 1727, 1, 0, 0, 0, 0, 1729, 1, 0, 0, 0, 0, 1731, + 1, 0, 0, 0, 0, 1733, 1, 0, 0, 0, 0, 1735, 1, 0, 0, 0, 0, 1737, 1, 0, 0, + 0, 0, 1739, 1, 0, 0, 0, 0, 1741, 1, 0, 0, 0, 0, 1743, 1, 0, 0, 0, 0, 1745, + 1, 0, 0, 0, 0, 1747, 1, 0, 0, 0, 0, 1749, 1, 0, 0, 0, 0, 1751, 1, 0, 0, + 0, 0, 1753, 1, 0, 0, 0, 0, 1755, 1, 0, 0, 0, 0, 1757, 1, 0, 0, 0, 0, 1759, + 1, 0, 0, 0, 0, 1761, 1, 0, 0, 0, 0, 1763, 1, 0, 0, 0, 0, 1765, 1, 0, 0, + 0, 0, 1767, 1, 0, 0, 0, 0, 1769, 1, 0, 0, 0, 0, 1771, 1, 0, 0, 0, 0, 1773, + 1, 0, 0, 0, 0, 1775, 1, 0, 0, 0, 0, 1777, 1, 0, 0, 0, 0, 1779, 1, 0, 0, + 0, 0, 1781, 1, 0, 0, 0, 0, 1783, 1, 0, 0, 0, 0, 1785, 1, 0, 0, 0, 0, 1787, + 1, 0, 0, 0, 0, 1789, 1, 0, 0, 0, 0, 1791, 1, 0, 0, 0, 0, 1793, 1, 0, 0, + 0, 0, 1795, 1, 0, 0, 0, 0, 1797, 1, 0, 0, 0, 0, 1799, 1, 0, 0, 0, 0, 1801, + 1, 0, 0, 0, 0, 1803, 1, 0, 0, 0, 0, 1805, 1, 0, 0, 0, 0, 1807, 1, 0, 0, + 0, 0, 1809, 1, 0, 0, 0, 0, 1811, 1, 0, 0, 0, 0, 1813, 1, 0, 0, 0, 0, 1815, + 1, 0, 0, 0, 0, 1817, 1, 0, 0, 0, 0, 1819, 1, 0, 0, 0, 0, 1821, 1, 0, 0, + 0, 0, 1823, 1, 0, 0, 0, 0, 1825, 1, 0, 0, 0, 0, 1827, 1, 0, 0, 0, 0, 1829, + 1, 0, 0, 0, 0, 1831, 1, 0, 0, 0, 0, 1833, 1, 0, 0, 0, 0, 1835, 1, 0, 0, + 0, 0, 1837, 1, 0, 0, 0, 0, 1839, 1, 0, 0, 0, 0, 1841, 1, 0, 0, 0, 0, 1843, + 1, 0, 0, 0, 0, 1845, 1, 0, 0, 0, 0, 1847, 1, 0, 0, 0, 0, 1849, 1, 0, 0, + 0, 0, 1851, 1, 0, 0, 0, 0, 1853, 1, 0, 0, 0, 0, 1855, 1, 0, 0, 0, 0, 1857, + 1, 0, 0, 0, 0, 1859, 1, 0, 0, 0, 0, 1861, 1, 0, 0, 0, 0, 1863, 1, 0, 0, + 0, 0, 1865, 1, 0, 0, 0, 0, 1867, 1, 0, 0, 0, 0, 1869, 1, 0, 0, 0, 0, 1871, + 1, 0, 0, 0, 0, 1873, 1, 0, 0, 0, 0, 1875, 1, 0, 0, 0, 0, 1877, 1, 0, 0, + 0, 0, 1879, 1, 0, 0, 0, 0, 1881, 1, 0, 0, 0, 0, 1883, 1, 0, 0, 0, 0, 1885, + 1, 0, 0, 0, 0, 1887, 1, 0, 0, 0, 0, 1889, 1, 0, 0, 0, 0, 1891, 1, 0, 0, + 0, 0, 1893, 1, 0, 0, 0, 0, 1895, 1, 0, 0, 0, 0, 1897, 1, 0, 0, 0, 0, 1899, + 1, 0, 0, 0, 0, 1901, 1, 0, 0, 0, 0, 1903, 1, 0, 0, 0, 0, 1905, 1, 0, 0, + 0, 0, 1907, 1, 0, 0, 0, 0, 1909, 1, 0, 0, 0, 0, 1911, 1, 0, 0, 0, 0, 1913, + 1, 0, 0, 0, 0, 1915, 1, 0, 0, 0, 0, 1917, 1, 0, 0, 0, 0, 1919, 1, 0, 0, + 0, 0, 1921, 1, 0, 0, 0, 0, 1923, 1, 0, 0, 0, 0, 1925, 1, 0, 0, 0, 0, 1927, + 1, 0, 0, 0, 0, 1929, 1, 0, 0, 0, 0, 1931, 1, 0, 0, 0, 0, 1933, 1, 0, 0, + 0, 0, 1935, 1, 0, 0, 0, 0, 1937, 1, 0, 0, 0, 0, 1939, 1, 0, 0, 0, 0, 1941, + 1, 0, 0, 0, 0, 1943, 1, 0, 0, 0, 0, 1945, 1, 0, 0, 0, 0, 1947, 1, 0, 0, + 0, 0, 1949, 1, 0, 0, 0, 0, 1951, 1, 0, 0, 0, 0, 1953, 1, 0, 0, 0, 0, 1955, + 1, 0, 0, 0, 0, 1957, 1, 0, 0, 0, 0, 1959, 1, 0, 0, 0, 0, 1961, 1, 0, 0, + 0, 0, 1963, 1, 0, 0, 0, 0, 1965, 1, 0, 0, 0, 0, 1967, 1, 0, 0, 0, 0, 1969, + 1, 0, 0, 0, 0, 1971, 1, 0, 0, 0, 0, 1973, 1, 0, 0, 0, 0, 1975, 1, 0, 0, + 0, 0, 1977, 1, 0, 0, 0, 0, 1979, 1, 0, 0, 0, 0, 1981, 1, 0, 0, 0, 0, 1983, + 1, 0, 0, 0, 0, 1985, 1, 0, 0, 0, 0, 1987, 1, 0, 0, 0, 0, 1989, 1, 0, 0, + 0, 0, 1991, 1, 0, 0, 0, 0, 1993, 1, 0, 0, 0, 0, 1995, 1, 0, 0, 0, 0, 1997, + 1, 0, 0, 0, 0, 1999, 1, 0, 0, 0, 0, 2001, 1, 0, 0, 0, 0, 2003, 1, 0, 0, + 0, 0, 2005, 1, 0, 0, 0, 0, 2007, 1, 0, 0, 0, 0, 2009, 1, 0, 0, 0, 0, 2011, + 1, 0, 0, 0, 0, 2013, 1, 0, 0, 0, 0, 2015, 1, 0, 0, 0, 0, 2017, 1, 0, 0, + 0, 0, 2019, 1, 0, 0, 0, 0, 2021, 1, 0, 0, 0, 0, 2023, 1, 0, 0, 0, 0, 2025, + 1, 0, 0, 0, 0, 2027, 1, 0, 0, 0, 0, 2029, 1, 0, 0, 0, 0, 2031, 1, 0, 0, + 0, 0, 2033, 1, 0, 0, 0, 0, 2035, 1, 0, 0, 0, 0, 2037, 1, 0, 0, 0, 0, 2039, + 1, 0, 0, 0, 0, 2041, 1, 0, 0, 0, 0, 2043, 1, 0, 0, 0, 0, 2045, 1, 0, 0, + 0, 0, 2047, 1, 0, 0, 0, 0, 2049, 1, 0, 0, 0, 0, 2051, 1, 0, 0, 0, 0, 2053, + 1, 0, 0, 0, 0, 2055, 1, 0, 0, 0, 0, 2057, 1, 0, 0, 0, 0, 2059, 1, 0, 0, + 0, 0, 2061, 1, 0, 0, 0, 0, 2063, 1, 0, 0, 0, 0, 2065, 1, 0, 0, 0, 0, 2067, + 1, 0, 0, 0, 0, 2069, 1, 0, 0, 0, 0, 2071, 1, 0, 0, 0, 0, 2073, 1, 0, 0, + 0, 0, 2075, 1, 0, 0, 0, 0, 2077, 1, 0, 0, 0, 0, 2079, 1, 0, 0, 0, 0, 2081, + 1, 0, 0, 0, 0, 2083, 1, 0, 0, 0, 0, 2085, 1, 0, 0, 0, 0, 2087, 1, 0, 0, + 0, 0, 2089, 1, 0, 0, 0, 0, 2091, 1, 0, 0, 0, 0, 2093, 1, 0, 0, 0, 0, 2095, + 1, 0, 0, 0, 0, 2097, 1, 0, 0, 0, 0, 2099, 1, 0, 0, 0, 0, 2101, 1, 0, 0, + 0, 0, 2103, 1, 0, 0, 0, 0, 2105, 1, 0, 0, 0, 0, 2107, 1, 0, 0, 0, 0, 2109, + 1, 0, 0, 0, 0, 2111, 1, 0, 0, 0, 0, 2113, 1, 0, 0, 0, 0, 2115, 1, 0, 0, + 0, 0, 2117, 1, 0, 0, 0, 0, 2119, 1, 0, 0, 0, 0, 2121, 1, 0, 0, 0, 0, 2123, + 1, 0, 0, 0, 0, 2125, 1, 0, 0, 0, 0, 2127, 1, 0, 0, 0, 0, 2129, 1, 0, 0, + 0, 0, 2131, 1, 0, 0, 0, 0, 2133, 1, 0, 0, 0, 0, 2135, 1, 0, 0, 0, 0, 2137, + 1, 0, 0, 0, 0, 2139, 1, 0, 0, 0, 0, 2141, 1, 0, 0, 0, 0, 2143, 1, 0, 0, + 0, 0, 2145, 1, 0, 0, 0, 0, 2147, 1, 0, 0, 0, 0, 2149, 1, 0, 0, 0, 0, 2151, + 1, 0, 0, 0, 0, 2153, 1, 0, 0, 0, 0, 2155, 1, 0, 0, 0, 0, 2157, 1, 0, 0, + 0, 0, 2159, 1, 0, 0, 0, 0, 2161, 1, 0, 0, 0, 0, 2163, 1, 0, 0, 0, 0, 2165, + 1, 0, 0, 0, 0, 2167, 1, 0, 0, 0, 0, 2169, 1, 0, 0, 0, 0, 2171, 1, 0, 0, + 0, 0, 2173, 1, 0, 0, 0, 0, 2175, 1, 0, 0, 0, 0, 2177, 1, 0, 0, 0, 0, 2179, + 1, 0, 0, 0, 0, 2181, 1, 0, 0, 0, 0, 2183, 1, 0, 0, 0, 0, 2185, 1, 0, 0, + 0, 0, 2187, 1, 0, 0, 0, 0, 2189, 1, 0, 0, 0, 0, 2191, 1, 0, 0, 0, 0, 2193, + 1, 0, 0, 0, 0, 2195, 1, 0, 0, 0, 0, 2197, 1, 0, 0, 0, 0, 2199, 1, 0, 0, + 0, 0, 2201, 1, 0, 0, 0, 0, 2203, 1, 0, 0, 0, 0, 2205, 1, 0, 0, 0, 0, 2207, + 1, 0, 0, 0, 0, 2209, 1, 0, 0, 0, 0, 2211, 1, 0, 0, 0, 0, 2213, 1, 0, 0, + 0, 0, 2215, 1, 0, 0, 0, 0, 2217, 1, 0, 0, 0, 0, 2219, 1, 0, 0, 0, 0, 2221, + 1, 0, 0, 0, 0, 2223, 1, 0, 0, 0, 0, 2225, 1, 0, 0, 0, 0, 2227, 1, 0, 0, + 0, 0, 2229, 1, 0, 0, 0, 0, 2231, 1, 0, 0, 0, 0, 2233, 1, 0, 0, 0, 0, 2235, + 1, 0, 0, 0, 0, 2237, 1, 0, 0, 0, 0, 2239, 1, 0, 0, 0, 0, 2241, 1, 0, 0, + 0, 0, 2243, 1, 0, 0, 0, 0, 2245, 1, 0, 0, 0, 0, 2247, 1, 0, 0, 0, 0, 2249, + 1, 0, 0, 0, 0, 2251, 1, 0, 0, 0, 0, 2253, 1, 0, 0, 0, 0, 2255, 1, 0, 0, + 0, 0, 2257, 1, 0, 0, 0, 0, 2259, 1, 0, 0, 0, 0, 2261, 1, 0, 0, 0, 0, 2263, + 1, 0, 0, 0, 0, 2265, 1, 0, 0, 0, 0, 2267, 1, 0, 0, 0, 0, 2269, 1, 0, 0, + 0, 0, 2271, 1, 0, 0, 0, 0, 2273, 1, 0, 0, 0, 0, 2275, 1, 0, 0, 0, 0, 2277, + 1, 0, 0, 0, 0, 2279, 1, 0, 0, 0, 0, 2281, 1, 0, 0, 0, 0, 2283, 1, 0, 0, + 0, 0, 2285, 1, 0, 0, 0, 0, 2287, 1, 0, 0, 0, 0, 2289, 1, 0, 0, 0, 0, 2291, + 1, 0, 0, 0, 0, 2293, 1, 0, 0, 0, 0, 2295, 1, 0, 0, 0, 0, 2297, 1, 0, 0, + 0, 0, 2301, 1, 0, 0, 0, 0, 2303, 1, 0, 0, 0, 0, 2305, 1, 0, 0, 0, 0, 2307, + 1, 0, 0, 0, 0, 2309, 1, 0, 0, 0, 0, 2311, 1, 0, 0, 0, 0, 2313, 1, 0, 0, + 0, 0, 2315, 1, 0, 0, 0, 0, 2317, 1, 0, 0, 0, 0, 2319, 1, 0, 0, 0, 0, 2321, + 1, 0, 0, 0, 0, 2323, 1, 0, 0, 0, 0, 2325, 1, 0, 0, 0, 0, 2327, 1, 0, 0, + 0, 0, 2329, 1, 0, 0, 0, 0, 2331, 1, 0, 0, 0, 0, 2353, 1, 0, 0, 0, 1, 2356, + 1, 0, 0, 0, 3, 2362, 1, 0, 0, 0, 5, 2376, 1, 0, 0, 0, 7, 2425, 1, 0, 0, + 0, 9, 2429, 1, 0, 0, 0, 11, 2433, 1, 0, 0, 0, 13, 2437, 1, 0, 0, 0, 15, + 2443, 1, 0, 0, 0, 17, 2450, 1, 0, 0, 0, 19, 2458, 1, 0, 0, 0, 21, 2462, + 1, 0, 0, 0, 23, 2468, 1, 0, 0, 0, 25, 2471, 1, 0, 0, 0, 27, 2475, 1, 0, + 0, 0, 29, 2485, 1, 0, 0, 0, 31, 2492, 1, 0, 0, 0, 33, 2500, 1, 0, 0, 0, + 35, 2505, 1, 0, 0, 0, 37, 2513, 1, 0, 0, 0, 39, 2516, 1, 0, 0, 0, 41, 2521, + 1, 0, 0, 0, 43, 2529, 1, 0, 0, 0, 45, 2534, 1, 0, 0, 0, 47, 2539, 1, 0, + 0, 0, 49, 2546, 1, 0, 0, 0, 51, 2556, 1, 0, 0, 0, 53, 2562, 1, 0, 0, 0, + 55, 2570, 1, 0, 0, 0, 57, 2577, 1, 0, 0, 0, 59, 2587, 1, 0, 0, 0, 61, 2598, + 1, 0, 0, 0, 63, 2607, 1, 0, 0, 0, 65, 2615, 1, 0, 0, 0, 67, 2622, 1, 0, + 0, 0, 69, 2628, 1, 0, 0, 0, 71, 2636, 1, 0, 0, 0, 73, 2649, 1, 0, 0, 0, + 75, 2662, 1, 0, 0, 0, 77, 2669, 1, 0, 0, 0, 79, 2678, 1, 0, 0, 0, 81, 2688, + 1, 0, 0, 0, 83, 2696, 1, 0, 0, 0, 85, 2704, 1, 0, 0, 0, 87, 2712, 1, 0, + 0, 0, 89, 2719, 1, 0, 0, 0, 91, 2724, 1, 0, 0, 0, 93, 2733, 1, 0, 0, 0, + 95, 2747, 1, 0, 0, 0, 97, 2759, 1, 0, 0, 0, 99, 2768, 1, 0, 0, 0, 101, + 2780, 1, 0, 0, 0, 103, 2785, 1, 0, 0, 0, 105, 2790, 1, 0, 0, 0, 107, 2795, + 1, 0, 0, 0, 109, 2802, 1, 0, 0, 0, 111, 2808, 1, 0, 0, 0, 113, 2817, 1, + 0, 0, 0, 115, 2826, 1, 0, 0, 0, 117, 2834, 1, 0, 0, 0, 119, 2841, 1, 0, + 0, 0, 121, 2848, 1, 0, 0, 0, 123, 2853, 1, 0, 0, 0, 125, 2861, 1, 0, 0, + 0, 127, 2867, 1, 0, 0, 0, 129, 2873, 1, 0, 0, 0, 131, 2877, 1, 0, 0, 0, + 133, 2883, 1, 0, 0, 0, 135, 2891, 1, 0, 0, 0, 137, 2896, 1, 0, 0, 0, 139, + 2905, 1, 0, 0, 0, 141, 2915, 1, 0, 0, 0, 143, 2919, 1, 0, 0, 0, 145, 2925, + 1, 0, 0, 0, 147, 2931, 1, 0, 0, 0, 149, 2938, 1, 0, 0, 0, 151, 2952, 1, + 0, 0, 0, 153, 2962, 1, 0, 0, 0, 155, 2965, 1, 0, 0, 0, 157, 2972, 1, 0, + 0, 0, 159, 2980, 1, 0, 0, 0, 161, 2983, 1, 0, 0, 0, 163, 2989, 1, 0, 0, + 0, 165, 2996, 1, 0, 0, 0, 167, 3002, 1, 0, 0, 0, 169, 3008, 1, 0, 0, 0, + 171, 3015, 1, 0, 0, 0, 173, 3024, 1, 0, 0, 0, 175, 3029, 1, 0, 0, 0, 177, + 3032, 1, 0, 0, 0, 179, 3040, 1, 0, 0, 0, 181, 3045, 1, 0, 0, 0, 183, 3049, + 1, 0, 0, 0, 185, 3054, 1, 0, 0, 0, 187, 3059, 1, 0, 0, 0, 189, 3067, 1, + 0, 0, 0, 191, 3075, 1, 0, 0, 0, 193, 3081, 1, 0, 0, 0, 195, 3086, 1, 0, + 0, 0, 197, 3091, 1, 0, 0, 0, 199, 3097, 1, 0, 0, 0, 201, 3104, 1, 0, 0, + 0, 203, 3110, 1, 0, 0, 0, 205, 3115, 1, 0, 0, 0, 207, 3120, 1, 0, 0, 0, + 209, 3127, 1, 0, 0, 0, 211, 3132, 1, 0, 0, 0, 213, 3145, 1, 0, 0, 0, 215, + 3157, 1, 0, 0, 0, 217, 3187, 1, 0, 0, 0, 219, 3193, 1, 0, 0, 0, 221, 3202, + 1, 0, 0, 0, 223, 3211, 1, 0, 0, 0, 225, 3220, 1, 0, 0, 0, 227, 3228, 1, + 0, 0, 0, 229, 3232, 1, 0, 0, 0, 231, 3251, 1, 0, 0, 0, 233, 3256, 1, 0, + 0, 0, 235, 3263, 1, 0, 0, 0, 237, 3266, 1, 0, 0, 0, 239, 3275, 1, 0, 0, + 0, 241, 3282, 1, 0, 0, 0, 243, 3291, 1, 0, 0, 0, 245, 3302, 1, 0, 0, 0, + 247, 3305, 1, 0, 0, 0, 249, 3311, 1, 0, 0, 0, 251, 3315, 1, 0, 0, 0, 253, + 3321, 1, 0, 0, 0, 255, 3329, 1, 0, 0, 0, 257, 3334, 1, 0, 0, 0, 259, 3344, + 1, 0, 0, 0, 261, 3352, 1, 0, 0, 0, 263, 3362, 1, 0, 0, 0, 265, 3368, 1, + 0, 0, 0, 267, 3374, 1, 0, 0, 0, 269, 3379, 1, 0, 0, 0, 271, 3385, 1, 0, + 0, 0, 273, 3396, 1, 0, 0, 0, 275, 3403, 1, 0, 0, 0, 277, 3411, 1, 0, 0, + 0, 279, 3418, 1, 0, 0, 0, 281, 3425, 1, 0, 0, 0, 283, 3433, 1, 0, 0, 0, + 285, 3441, 1, 0, 0, 0, 287, 3450, 1, 0, 0, 0, 289, 3459, 1, 0, 0, 0, 291, + 3466, 1, 0, 0, 0, 293, 3473, 1, 0, 0, 0, 295, 3480, 1, 0, 0, 0, 297, 3486, + 1, 0, 0, 0, 299, 3492, 1, 0, 0, 0, 301, 3499, 1, 0, 0, 0, 303, 3507, 1, + 0, 0, 0, 305, 3514, 1, 0, 0, 0, 307, 3518, 1, 0, 0, 0, 309, 3528, 1, 0, + 0, 0, 311, 3533, 1, 0, 0, 0, 313, 3540, 1, 0, 0, 0, 315, 3545, 1, 0, 0, + 0, 317, 3564, 1, 0, 0, 0, 319, 3572, 1, 0, 0, 0, 321, 3576, 1, 0, 0, 0, + 323, 3589, 1, 0, 0, 0, 325, 3598, 1, 0, 0, 0, 327, 3609, 1, 0, 0, 0, 329, + 3624, 1, 0, 0, 0, 331, 3644, 1, 0, 0, 0, 333, 3661, 1, 0, 0, 0, 335, 3665, + 1, 0, 0, 0, 337, 3673, 1, 0, 0, 0, 339, 3682, 1, 0, 0, 0, 341, 3692, 1, + 0, 0, 0, 343, 3706, 1, 0, 0, 0, 345, 3712, 1, 0, 0, 0, 347, 3723, 1, 0, + 0, 0, 349, 3728, 1, 0, 0, 0, 351, 3731, 1, 0, 0, 0, 353, 3740, 1, 0, 0, + 0, 355, 3748, 1, 0, 0, 0, 357, 3753, 1, 0, 0, 0, 359, 3758, 1, 0, 0, 0, + 361, 3764, 1, 0, 0, 0, 363, 3771, 1, 0, 0, 0, 365, 3778, 1, 0, 0, 0, 367, + 3787, 1, 0, 0, 0, 369, 3794, 1, 0, 0, 0, 371, 3800, 1, 0, 0, 0, 373, 3804, + 1, 0, 0, 0, 375, 3810, 1, 0, 0, 0, 377, 3817, 1, 0, 0, 0, 379, 3822, 1, + 0, 0, 0, 381, 3828, 1, 0, 0, 0, 383, 3834, 1, 0, 0, 0, 385, 3839, 1, 0, + 0, 0, 387, 3845, 1, 0, 0, 0, 389, 3849, 1, 0, 0, 0, 391, 3858, 1, 0, 0, + 0, 393, 3866, 1, 0, 0, 0, 395, 3875, 1, 0, 0, 0, 397, 3885, 1, 0, 0, 0, + 399, 3895, 1, 0, 0, 0, 401, 3899, 1, 0, 0, 0, 403, 3904, 1, 0, 0, 0, 405, + 3909, 1, 0, 0, 0, 407, 3914, 1, 0, 0, 0, 409, 3919, 1, 0, 0, 0, 411, 3924, + 1, 0, 0, 0, 413, 3932, 1, 0, 0, 0, 415, 3939, 1, 0, 0, 0, 417, 3944, 1, + 0, 0, 0, 419, 3951, 1, 0, 0, 0, 421, 3961, 1, 0, 0, 0, 423, 3967, 1, 0, + 0, 0, 425, 3974, 1, 0, 0, 0, 427, 3981, 1, 0, 0, 0, 429, 3989, 1, 0, 0, + 0, 431, 3993, 1, 0, 0, 0, 433, 4001, 1, 0, 0, 0, 435, 4006, 1, 0, 0, 0, + 437, 4011, 1, 0, 0, 0, 439, 4021, 1, 0, 0, 0, 441, 4030, 1, 0, 0, 0, 443, + 4035, 1, 0, 0, 0, 445, 4040, 1, 0, 0, 0, 447, 4048, 1, 0, 0, 0, 449, 4057, + 1, 0, 0, 0, 451, 4066, 1, 0, 0, 0, 453, 4073, 1, 0, 0, 0, 455, 4083, 1, + 0, 0, 0, 457, 4092, 1, 0, 0, 0, 459, 4097, 1, 0, 0, 0, 461, 4108, 1, 0, + 0, 0, 463, 4113, 1, 0, 0, 0, 465, 4122, 1, 0, 0, 0, 467, 4131, 1, 0, 0, + 0, 469, 4136, 1, 0, 0, 0, 471, 4147, 1, 0, 0, 0, 473, 4156, 1, 0, 0, 0, + 475, 4161, 1, 0, 0, 0, 477, 4169, 1, 0, 0, 0, 479, 4176, 1, 0, 0, 0, 481, + 4183, 1, 0, 0, 0, 483, 4194, 1, 0, 0, 0, 485, 4203, 1, 0, 0, 0, 487, 4214, + 1, 0, 0, 0, 489, 4225, 1, 0, 0, 0, 491, 4237, 1, 0, 0, 0, 493, 4249, 1, + 0, 0, 0, 495, 4263, 1, 0, 0, 0, 497, 4282, 1, 0, 0, 0, 499, 4301, 1, 0, + 0, 0, 501, 4318, 1, 0, 0, 0, 503, 4334, 1, 0, 0, 0, 505, 4345, 1, 0, 0, + 0, 507, 4359, 1, 0, 0, 0, 509, 4377, 1, 0, 0, 0, 511, 4395, 1, 0, 0, 0, + 513, 4409, 1, 0, 0, 0, 515, 4428, 1, 0, 0, 0, 517, 4439, 1, 0, 0, 0, 519, + 4452, 1, 0, 0, 0, 521, 4464, 1, 0, 0, 0, 523, 4474, 1, 0, 0, 0, 525, 4486, + 1, 0, 0, 0, 527, 4497, 1, 0, 0, 0, 529, 4514, 1, 0, 0, 0, 531, 4534, 1, + 0, 0, 0, 533, 4546, 1, 0, 0, 0, 535, 4561, 1, 0, 0, 0, 537, 4575, 1, 0, + 0, 0, 539, 4587, 1, 0, 0, 0, 541, 4598, 1, 0, 0, 0, 543, 4610, 1, 0, 0, + 0, 545, 4623, 1, 0, 0, 0, 547, 4641, 1, 0, 0, 0, 549, 4671, 1, 0, 0, 0, + 551, 4683, 1, 0, 0, 0, 553, 4692, 1, 0, 0, 0, 555, 4710, 1, 0, 0, 0, 557, + 4728, 1, 0, 0, 0, 559, 4739, 1, 0, 0, 0, 561, 4749, 1, 0, 0, 0, 563, 4762, + 1, 0, 0, 0, 565, 4773, 1, 0, 0, 0, 567, 4784, 1, 0, 0, 0, 569, 4791, 1, + 0, 0, 0, 571, 4802, 1, 0, 0, 0, 573, 4807, 1, 0, 0, 0, 575, 4811, 1, 0, + 0, 0, 577, 4819, 1, 0, 0, 0, 579, 4826, 1, 0, 0, 0, 581, 4834, 1, 0, 0, + 0, 583, 4840, 1, 0, 0, 0, 585, 4850, 1, 0, 0, 0, 587, 4861, 1, 0, 0, 0, + 589, 4873, 1, 0, 0, 0, 591, 4886, 1, 0, 0, 0, 593, 4890, 1, 0, 0, 0, 595, + 4901, 1, 0, 0, 0, 597, 4906, 1, 0, 0, 0, 599, 4910, 1, 0, 0, 0, 601, 4914, + 1, 0, 0, 0, 603, 4920, 1, 0, 0, 0, 605, 4930, 1, 0, 0, 0, 607, 4943, 1, + 0, 0, 0, 609, 4948, 1, 0, 0, 0, 611, 4959, 1, 0, 0, 0, 613, 4963, 1, 0, + 0, 0, 615, 4970, 1, 0, 0, 0, 617, 4981, 1, 0, 0, 0, 619, 4993, 1, 0, 0, + 0, 621, 4997, 1, 0, 0, 0, 623, 5005, 1, 0, 0, 0, 625, 5014, 1, 0, 0, 0, + 627, 5023, 1, 0, 0, 0, 629, 5036, 1, 0, 0, 0, 631, 5049, 1, 0, 0, 0, 633, + 5067, 1, 0, 0, 0, 635, 5077, 1, 0, 0, 0, 637, 5085, 1, 0, 0, 0, 639, 5093, + 1, 0, 0, 0, 641, 5102, 1, 0, 0, 0, 643, 5111, 1, 0, 0, 0, 645, 5119, 1, + 0, 0, 0, 647, 5134, 1, 0, 0, 0, 649, 5138, 1, 0, 0, 0, 651, 5147, 1, 0, + 0, 0, 653, 5154, 1, 0, 0, 0, 655, 5164, 1, 0, 0, 0, 657, 5172, 1, 0, 0, + 0, 659, 5177, 1, 0, 0, 0, 661, 5186, 1, 0, 0, 0, 663, 5195, 1, 0, 0, 0, + 665, 5209, 1, 0, 0, 0, 667, 5217, 1, 0, 0, 0, 669, 5224, 1, 0, 0, 0, 671, + 5230, 1, 0, 0, 0, 673, 5240, 1, 0, 0, 0, 675, 5250, 1, 0, 0, 0, 677, 5254, + 1, 0, 0, 0, 679, 5257, 1, 0, 0, 0, 681, 5265, 1, 0, 0, 0, 683, 5276, 1, + 0, 0, 0, 685, 5292, 1, 0, 0, 0, 687, 5307, 1, 0, 0, 0, 689, 5322, 1, 0, + 0, 0, 691, 5328, 1, 0, 0, 0, 693, 5335, 1, 0, 0, 0, 695, 5339, 1, 0, 0, + 0, 697, 5345, 1, 0, 0, 0, 699, 5350, 1, 0, 0, 0, 701, 5358, 1, 0, 0, 0, + 703, 5364, 1, 0, 0, 0, 705, 5370, 1, 0, 0, 0, 707, 5379, 1, 0, 0, 0, 709, + 5385, 1, 0, 0, 0, 711, 5393, 1, 0, 0, 0, 713, 5401, 1, 0, 0, 0, 715, 5410, + 1, 0, 0, 0, 717, 5424, 1, 0, 0, 0, 719, 5431, 1, 0, 0, 0, 721, 5444, 1, + 0, 0, 0, 723, 5451, 1, 0, 0, 0, 725, 5457, 1, 0, 0, 0, 727, 5468, 1, 0, + 0, 0, 729, 5477, 1, 0, 0, 0, 731, 5482, 1, 0, 0, 0, 733, 5490, 1, 0, 0, + 0, 735, 5504, 1, 0, 0, 0, 737, 5516, 1, 0, 0, 0, 739, 5524, 1, 0, 0, 0, + 741, 5531, 1, 0, 0, 0, 743, 5539, 1, 0, 0, 0, 745, 5550, 1, 0, 0, 0, 747, + 5561, 1, 0, 0, 0, 749, 5573, 1, 0, 0, 0, 751, 5584, 1, 0, 0, 0, 753, 5592, + 1, 0, 0, 0, 755, 5603, 1, 0, 0, 0, 757, 5614, 1, 0, 0, 0, 759, 5633, 1, + 0, 0, 0, 761, 5651, 1, 0, 0, 0, 763, 5667, 1, 0, 0, 0, 765, 5676, 1, 0, + 0, 0, 767, 5684, 1, 0, 0, 0, 769, 5697, 1, 0, 0, 0, 771, 5702, 1, 0, 0, + 0, 773, 5706, 1, 0, 0, 0, 775, 5712, 1, 0, 0, 0, 777, 5724, 1, 0, 0, 0, + 779, 5729, 1, 0, 0, 0, 781, 5738, 1, 0, 0, 0, 783, 5749, 1, 0, 0, 0, 785, + 5762, 1, 0, 0, 0, 787, 5770, 1, 0, 0, 0, 789, 5786, 1, 0, 0, 0, 791, 5799, + 1, 0, 0, 0, 793, 5809, 1, 0, 0, 0, 795, 5817, 1, 0, 0, 0, 797, 5825, 1, + 0, 0, 0, 799, 5830, 1, 0, 0, 0, 801, 5833, 1, 0, 0, 0, 803, 5842, 1, 0, + 0, 0, 805, 5852, 1, 0, 0, 0, 807, 5860, 1, 0, 0, 0, 809, 5867, 1, 0, 0, + 0, 811, 5877, 1, 0, 0, 0, 813, 5888, 1, 0, 0, 0, 815, 5906, 1, 0, 0, 0, + 817, 5910, 1, 0, 0, 0, 819, 5915, 1, 0, 0, 0, 821, 5922, 1, 0, 0, 0, 823, + 5930, 1, 0, 0, 0, 825, 5936, 1, 0, 0, 0, 827, 5943, 1, 0, 0, 0, 829, 5950, + 1, 0, 0, 0, 831, 5955, 1, 0, 0, 0, 833, 5961, 1, 0, 0, 0, 835, 5968, 1, + 0, 0, 0, 837, 5974, 1, 0, 0, 0, 839, 5983, 1, 0, 0, 0, 841, 5993, 1, 0, + 0, 0, 843, 6000, 1, 0, 0, 0, 845, 6007, 1, 0, 0, 0, 847, 6016, 1, 0, 0, + 0, 849, 6028, 1, 0, 0, 0, 851, 6050, 1, 0, 0, 0, 853, 6055, 1, 0, 0, 0, + 855, 6062, 1, 0, 0, 0, 857, 6069, 1, 0, 0, 0, 859, 6085, 1, 0, 0, 0, 861, + 6092, 1, 0, 0, 0, 863, 6098, 1, 0, 0, 0, 865, 6104, 1, 0, 0, 0, 867, 6110, + 1, 0, 0, 0, 869, 6120, 1, 0, 0, 0, 871, 6128, 1, 0, 0, 0, 873, 6134, 1, + 0, 0, 0, 875, 6139, 1, 0, 0, 0, 877, 6148, 1, 0, 0, 0, 879, 6156, 1, 0, + 0, 0, 881, 6163, 1, 0, 0, 0, 883, 6170, 1, 0, 0, 0, 885, 6188, 1, 0, 0, + 0, 887, 6196, 1, 0, 0, 0, 889, 6201, 1, 0, 0, 0, 891, 6206, 1, 0, 0, 0, + 893, 6214, 1, 0, 0, 0, 895, 6219, 1, 0, 0, 0, 897, 6225, 1, 0, 0, 0, 899, + 6236, 1, 0, 0, 0, 901, 6254, 1, 0, 0, 0, 903, 6261, 1, 0, 0, 0, 905, 6271, + 1, 0, 0, 0, 907, 6279, 1, 0, 0, 0, 909, 6292, 1, 0, 0, 0, 911, 6300, 1, + 0, 0, 0, 913, 6314, 1, 0, 0, 0, 915, 6322, 1, 0, 0, 0, 917, 6331, 1, 0, + 0, 0, 919, 6339, 1, 0, 0, 0, 921, 6349, 1, 0, 0, 0, 923, 6357, 1, 0, 0, + 0, 925, 6360, 1, 0, 0, 0, 927, 6370, 1, 0, 0, 0, 929, 6374, 1, 0, 0, 0, + 931, 6384, 1, 0, 0, 0, 933, 6391, 1, 0, 0, 0, 935, 6396, 1, 0, 0, 0, 937, + 6411, 1, 0, 0, 0, 939, 6420, 1, 0, 0, 0, 941, 6425, 1, 0, 0, 0, 943, 6432, + 1, 0, 0, 0, 945, 6437, 1, 0, 0, 0, 947, 6443, 1, 0, 0, 0, 949, 6448, 1, + 0, 0, 0, 951, 6454, 1, 0, 0, 0, 953, 6462, 1, 0, 0, 0, 955, 6467, 1, 0, + 0, 0, 957, 6474, 1, 0, 0, 0, 959, 6495, 1, 0, 0, 0, 961, 6516, 1, 0, 0, + 0, 963, 6529, 1, 0, 0, 0, 965, 6553, 1, 0, 0, 0, 967, 6565, 1, 0, 0, 0, + 969, 6581, 1, 0, 0, 0, 971, 6596, 1, 0, 0, 0, 973, 6612, 1, 0, 0, 0, 975, + 6624, 1, 0, 0, 0, 977, 6643, 1, 0, 0, 0, 979, 6654, 1, 0, 0, 0, 981, 6668, + 1, 0, 0, 0, 983, 6686, 1, 0, 0, 0, 985, 6702, 1, 0, 0, 0, 987, 6720, 1, + 0, 0, 0, 989, 6735, 1, 0, 0, 0, 991, 6754, 1, 0, 0, 0, 993, 6769, 1, 0, + 0, 0, 995, 6788, 1, 0, 0, 0, 997, 6800, 1, 0, 0, 0, 999, 6825, 1, 0, 0, + 0, 1001, 6846, 1, 0, 0, 0, 1003, 6855, 1, 0, 0, 0, 1005, 6864, 1, 0, 0, + 0, 1007, 6885, 1, 0, 0, 0, 1009, 6906, 1, 0, 0, 0, 1011, 6913, 1, 0, 0, + 0, 1013, 6920, 1, 0, 0, 0, 1015, 6926, 1, 0, 0, 0, 1017, 6939, 1, 0, 0, + 0, 1019, 6943, 1, 0, 0, 0, 1021, 6951, 1, 0, 0, 0, 1023, 6960, 1, 0, 0, + 0, 1025, 6965, 1, 0, 0, 0, 1027, 6972, 1, 0, 0, 0, 1029, 6978, 1, 0, 0, + 0, 1031, 6984, 1, 0, 0, 0, 1033, 6996, 1, 0, 0, 0, 1035, 7001, 1, 0, 0, + 0, 1037, 7007, 1, 0, 0, 0, 1039, 7013, 1, 0, 0, 0, 1041, 7019, 1, 0, 0, + 0, 1043, 7024, 1, 0, 0, 0, 1045, 7027, 1, 0, 0, 0, 1047, 7035, 1, 0, 0, + 0, 1049, 7042, 1, 0, 0, 0, 1051, 7050, 1, 0, 0, 0, 1053, 7061, 1, 0, 0, + 0, 1055, 7072, 1, 0, 0, 0, 1057, 7079, 1, 0, 0, 0, 1059, 7089, 1, 0, 0, + 0, 1061, 7094, 1, 0, 0, 0, 1063, 7099, 1, 0, 0, 0, 1065, 7107, 1, 0, 0, + 0, 1067, 7114, 1, 0, 0, 0, 1069, 7117, 1, 0, 0, 0, 1071, 7120, 1, 0, 0, + 0, 1073, 7133, 1, 0, 0, 0, 1075, 7137, 1, 0, 0, 0, 1077, 7144, 1, 0, 0, + 0, 1079, 7149, 1, 0, 0, 0, 1081, 7154, 1, 0, 0, 0, 1083, 7170, 1, 0, 0, + 0, 1085, 7178, 1, 0, 0, 0, 1087, 7184, 1, 0, 0, 0, 1089, 7194, 1, 0, 0, + 0, 1091, 7199, 1, 0, 0, 0, 1093, 7215, 1, 0, 0, 0, 1095, 7238, 1, 0, 0, + 0, 1097, 7245, 1, 0, 0, 0, 1099, 7253, 1, 0, 0, 0, 1101, 7266, 1, 0, 0, + 0, 1103, 7277, 1, 0, 0, 0, 1105, 7286, 1, 0, 0, 0, 1107, 7305, 1, 0, 0, + 0, 1109, 7311, 1, 0, 0, 0, 1111, 7318, 1, 0, 0, 0, 1113, 7329, 1, 0, 0, + 0, 1115, 7337, 1, 0, 0, 0, 1117, 7342, 1, 0, 0, 0, 1119, 7351, 1, 0, 0, + 0, 1121, 7361, 1, 0, 0, 0, 1123, 7369, 1, 0, 0, 0, 1125, 7378, 1, 0, 0, + 0, 1127, 7383, 1, 0, 0, 0, 1129, 7395, 1, 0, 0, 0, 1131, 7403, 1, 0, 0, + 0, 1133, 7412, 1, 0, 0, 0, 1135, 7418, 1, 0, 0, 0, 1137, 7424, 1, 0, 0, + 0, 1139, 7430, 1, 0, 0, 0, 1141, 7438, 1, 0, 0, 0, 1143, 7446, 1, 0, 0, + 0, 1145, 7456, 1, 0, 0, 0, 1147, 7473, 1, 0, 0, 0, 1149, 7483, 1, 0, 0, + 0, 1151, 7489, 1, 0, 0, 0, 1153, 7504, 1, 0, 0, 0, 1155, 7518, 1, 0, 0, + 0, 1157, 7527, 1, 0, 0, 0, 1159, 7534, 1, 0, 0, 0, 1161, 7545, 1, 0, 0, + 0, 1163, 7552, 1, 0, 0, 0, 1165, 7568, 1, 0, 0, 0, 1167, 7587, 1, 0, 0, + 0, 1169, 7607, 1, 0, 0, 0, 1171, 7630, 1, 0, 0, 0, 1173, 7651, 1, 0, 0, + 0, 1175, 7675, 1, 0, 0, 0, 1177, 7703, 1, 0, 0, 0, 1179, 7715, 1, 0, 0, + 0, 1181, 7721, 1, 0, 0, 0, 1183, 7729, 1, 0, 0, 0, 1185, 7736, 1, 0, 0, + 0, 1187, 7754, 1, 0, 0, 0, 1189, 7764, 1, 0, 0, 0, 1191, 7772, 1, 0, 0, + 0, 1193, 7778, 1, 0, 0, 0, 1195, 7783, 1, 0, 0, 0, 1197, 7792, 1, 0, 0, + 0, 1199, 7799, 1, 0, 0, 0, 1201, 7806, 1, 0, 0, 0, 1203, 7810, 1, 0, 0, + 0, 1205, 7815, 1, 0, 0, 0, 1207, 7826, 1, 0, 0, 0, 1209, 7832, 1, 0, 0, + 0, 1211, 7842, 1, 0, 0, 0, 1213, 7851, 1, 0, 0, 0, 1215, 7860, 1, 0, 0, + 0, 1217, 7869, 1, 0, 0, 0, 1219, 7876, 1, 0, 0, 0, 1221, 7884, 1, 0, 0, + 0, 1223, 7890, 1, 0, 0, 0, 1225, 7897, 1, 0, 0, 0, 1227, 7904, 1, 0, 0, + 0, 1229, 7911, 1, 0, 0, 0, 1231, 7917, 1, 0, 0, 0, 1233, 7922, 1, 0, 0, + 0, 1235, 7931, 1, 0, 0, 0, 1237, 7938, 1, 0, 0, 0, 1239, 7943, 1, 0, 0, + 0, 1241, 7950, 1, 0, 0, 0, 1243, 7957, 1, 0, 0, 0, 1245, 7964, 1, 0, 0, + 0, 1247, 7980, 1, 0, 0, 0, 1249, 7999, 1, 0, 0, 0, 1251, 8016, 1, 0, 0, + 0, 1253, 8034, 1, 0, 0, 0, 1255, 8044, 1, 0, 0, 0, 1257, 8057, 1, 0, 0, + 0, 1259, 8068, 1, 0, 0, 0, 1261, 8074, 1, 0, 0, 0, 1263, 8081, 1, 0, 0, + 0, 1265, 8099, 1, 0, 0, 0, 1267, 8116, 1, 0, 0, 0, 1269, 8135, 1, 0, 0, + 0, 1271, 8142, 1, 0, 0, 0, 1273, 8147, 1, 0, 0, 0, 1275, 8155, 1, 0, 0, + 0, 1277, 8162, 1, 0, 0, 0, 1279, 8169, 1, 0, 0, 0, 1281, 8185, 1, 0, 0, + 0, 1283, 8193, 1, 0, 0, 0, 1285, 8206, 1, 0, 0, 0, 1287, 8220, 1, 0, 0, + 0, 1289, 8228, 1, 0, 0, 0, 1291, 8234, 1, 0, 0, 0, 1293, 8243, 1, 0, 0, + 0, 1295, 8254, 1, 0, 0, 0, 1297, 8265, 1, 0, 0, 0, 1299, 8276, 1, 0, 0, + 0, 1301, 8286, 1, 0, 0, 0, 1303, 8296, 1, 0, 0, 0, 1305, 8301, 1, 0, 0, + 0, 1307, 8313, 1, 0, 0, 0, 1309, 8325, 1, 0, 0, 0, 1311, 8339, 1, 0, 0, + 0, 1313, 8348, 1, 0, 0, 0, 1315, 8357, 1, 0, 0, 0, 1317, 8367, 1, 0, 0, + 0, 1319, 8377, 1, 0, 0, 0, 1321, 8386, 1, 0, 0, 0, 1323, 8403, 1, 0, 0, + 0, 1325, 8413, 1, 0, 0, 0, 1327, 8421, 1, 0, 0, 0, 1329, 8427, 1, 0, 0, + 0, 1331, 8435, 1, 0, 0, 0, 1333, 8440, 1, 0, 0, 0, 1335, 8448, 1, 0, 0, + 0, 1337, 8463, 1, 0, 0, 0, 1339, 8474, 1, 0, 0, 0, 1341, 8480, 1, 0, 0, + 0, 1343, 8490, 1, 0, 0, 0, 1345, 8495, 1, 0, 0, 0, 1347, 8503, 1, 0, 0, + 0, 1349, 8511, 1, 0, 0, 0, 1351, 8516, 1, 0, 0, 0, 1353, 8525, 1, 0, 0, + 0, 1355, 8532, 1, 0, 0, 0, 1357, 8540, 1, 0, 0, 0, 1359, 8545, 1, 0, 0, + 0, 1361, 8553, 1, 0, 0, 0, 1363, 8558, 1, 0, 0, 0, 1365, 8561, 1, 0, 0, + 0, 1367, 8565, 1, 0, 0, 0, 1369, 8569, 1, 0, 0, 0, 1371, 8573, 1, 0, 0, + 0, 1373, 8577, 1, 0, 0, 0, 1375, 8581, 1, 0, 0, 0, 1377, 8585, 1, 0, 0, + 0, 1379, 8594, 1, 0, 0, 0, 1381, 8602, 1, 0, 0, 0, 1383, 8608, 1, 0, 0, + 0, 1385, 8612, 1, 0, 0, 0, 1387, 8617, 1, 0, 0, 0, 1389, 8624, 1, 0, 0, + 0, 1391, 8629, 1, 0, 0, 0, 1393, 8636, 1, 0, 0, 0, 1395, 8648, 1, 0, 0, + 0, 1397, 8654, 1, 0, 0, 0, 1399, 8681, 1, 0, 0, 0, 1401, 8700, 1, 0, 0, + 0, 1403, 8712, 1, 0, 0, 0, 1405, 8740, 1, 0, 0, 0, 1407, 8753, 1, 0, 0, + 0, 1409, 8766, 1, 0, 0, 0, 1411, 8790, 1, 0, 0, 0, 1413, 8802, 1, 0, 0, + 0, 1415, 8819, 1, 0, 0, 0, 1417, 8840, 1, 0, 0, 0, 1419, 8848, 1, 0, 0, + 0, 1421, 8853, 1, 0, 0, 0, 1423, 8868, 1, 0, 0, 0, 1425, 8884, 1, 0, 0, + 0, 1427, 8898, 1, 0, 0, 0, 1429, 8920, 1, 0, 0, 0, 1431, 8933, 1, 0, 0, + 0, 1433, 8946, 1, 0, 0, 0, 1435, 8967, 1, 0, 0, 0, 1437, 8991, 1, 0, 0, + 0, 1439, 9015, 1, 0, 0, 0, 1441, 9038, 1, 0, 0, 0, 1443, 9045, 1, 0, 0, + 0, 1445, 9052, 1, 0, 0, 0, 1447, 9068, 1, 0, 0, 0, 1449, 9092, 1, 0, 0, + 0, 1451, 9119, 1, 0, 0, 0, 1453, 9130, 1, 0, 0, 0, 1455, 9138, 1, 0, 0, + 0, 1457, 9145, 1, 0, 0, 0, 1459, 9165, 1, 0, 0, 0, 1461, 9189, 1, 0, 0, + 0, 1463, 9210, 1, 0, 0, 0, 1465, 9230, 1, 0, 0, 0, 1467, 9241, 1, 0, 0, + 0, 1469, 9249, 1, 0, 0, 0, 1471, 9252, 1, 0, 0, 0, 1473, 9278, 1, 0, 0, + 0, 1475, 9307, 1, 0, 0, 0, 1477, 9319, 1, 0, 0, 0, 1479, 9332, 1, 0, 0, + 0, 1481, 9341, 1, 0, 0, 0, 1483, 9347, 1, 0, 0, 0, 1485, 9370, 1, 0, 0, + 0, 1487, 9377, 1, 0, 0, 0, 1489, 9400, 1, 0, 0, 0, 1491, 9420, 1, 0, 0, + 0, 1493, 9437, 1, 0, 0, 0, 1495, 9446, 1, 0, 0, 0, 1497, 9452, 1, 0, 0, + 0, 1499, 9457, 1, 0, 0, 0, 1501, 9464, 1, 0, 0, 0, 1503, 9471, 1, 0, 0, + 0, 1505, 9478, 1, 0, 0, 0, 1507, 9485, 1, 0, 0, 0, 1509, 9491, 1, 0, 0, + 0, 1511, 9497, 1, 0, 0, 0, 1513, 9503, 1, 0, 0, 0, 1515, 9509, 1, 0, 0, + 0, 1517, 9514, 1, 0, 0, 0, 1519, 9522, 1, 0, 0, 0, 1521, 9528, 1, 0, 0, + 0, 1523, 9536, 1, 0, 0, 0, 1525, 9543, 1, 0, 0, 0, 1527, 9547, 1, 0, 0, + 0, 1529, 9555, 1, 0, 0, 0, 1531, 9561, 1, 0, 0, 0, 1533, 9568, 1, 0, 0, + 0, 1535, 9572, 1, 0, 0, 0, 1537, 9580, 1, 0, 0, 0, 1539, 9586, 1, 0, 0, + 0, 1541, 9592, 1, 0, 0, 0, 1543, 9599, 1, 0, 0, 0, 1545, 9606, 1, 0, 0, + 0, 1547, 9613, 1, 0, 0, 0, 1549, 9620, 1, 0, 0, 0, 1551, 9626, 1, 0, 0, + 0, 1553, 9635, 1, 0, 0, 0, 1555, 9640, 1, 0, 0, 0, 1557, 9645, 1, 0, 0, + 0, 1559, 9652, 1, 0, 0, 0, 1561, 9657, 1, 0, 0, 0, 1563, 9662, 1, 0, 0, + 0, 1565, 9668, 1, 0, 0, 0, 1567, 9676, 1, 0, 0, 0, 1569, 9682, 1, 0, 0, + 0, 1571, 9687, 1, 0, 0, 0, 1573, 9695, 1, 0, 0, 0, 1575, 9703, 1, 0, 0, + 0, 1577, 9711, 1, 0, 0, 0, 1579, 9721, 1, 0, 0, 0, 1581, 9725, 1, 0, 0, + 0, 1583, 9735, 1, 0, 0, 0, 1585, 9742, 1, 0, 0, 0, 1587, 9749, 1, 0, 0, + 0, 1589, 9760, 1, 0, 0, 0, 1591, 9767, 1, 0, 0, 0, 1593, 9771, 1, 0, 0, + 0, 1595, 9782, 1, 0, 0, 0, 1597, 9801, 1, 0, 0, 0, 1599, 9808, 1, 0, 0, + 0, 1601, 9819, 1, 0, 0, 0, 1603, 9829, 1, 0, 0, 0, 1605, 9841, 1, 0, 0, + 0, 1607, 9854, 1, 0, 0, 0, 1609, 9873, 1, 0, 0, 0, 1611, 9888, 1, 0, 0, + 0, 1613, 9897, 1, 0, 0, 0, 1615, 9908, 1, 0, 0, 0, 1617, 9924, 1, 0, 0, + 0, 1619, 9935, 1, 0, 0, 0, 1621, 9948, 1, 0, 0, 0, 1623, 9954, 1, 0, 0, + 0, 1625, 9962, 1, 0, 0, 0, 1627, 9966, 1, 0, 0, 0, 1629, 9971, 1, 0, 0, + 0, 1631, 9979, 1, 0, 0, 0, 1633, 9987, 1, 0, 0, 0, 1635, 9999, 1, 0, 0, + 0, 1637, 10011, 1, 0, 0, 0, 1639, 10016, 1, 0, 0, 0, 1641, 10025, 1, 0, + 0, 0, 1643, 10030, 1, 0, 0, 0, 1645, 10037, 1, 0, 0, 0, 1647, 10043, 1, + 0, 0, 0, 1649, 10049, 1, 0, 0, 0, 1651, 10068, 1, 0, 0, 0, 1653, 10086, + 1, 0, 0, 0, 1655, 10105, 1, 0, 0, 0, 1657, 10121, 1, 0, 0, 0, 1659, 10139, + 1, 0, 0, 0, 1661, 10144, 1, 0, 0, 0, 1663, 10150, 1, 0, 0, 0, 1665, 10160, + 1, 0, 0, 0, 1667, 10164, 1, 0, 0, 0, 1669, 10174, 1, 0, 0, 0, 1671, 10185, + 1, 0, 0, 0, 1673, 10192, 1, 0, 0, 0, 1675, 10205, 1, 0, 0, 0, 1677, 10210, + 1, 0, 0, 0, 1679, 10218, 1, 0, 0, 0, 1681, 10227, 1, 0, 0, 0, 1683, 10244, + 1, 0, 0, 0, 1685, 10252, 1, 0, 0, 0, 1687, 10264, 1, 0, 0, 0, 1689, 10277, + 1, 0, 0, 0, 1691, 10287, 1, 0, 0, 0, 1693, 10296, 1, 0, 0, 0, 1695, 10303, + 1, 0, 0, 0, 1697, 10313, 1, 0, 0, 0, 1699, 10327, 1, 0, 0, 0, 1701, 10332, + 1, 0, 0, 0, 1703, 10343, 1, 0, 0, 0, 1705, 10347, 1, 0, 0, 0, 1707, 10351, + 1, 0, 0, 0, 1709, 10357, 1, 0, 0, 0, 1711, 10384, 1, 0, 0, 0, 1713, 10410, + 1, 0, 0, 0, 1715, 10431, 1, 0, 0, 0, 1717, 10445, 1, 0, 0, 0, 1719, 10453, + 1, 0, 0, 0, 1721, 10462, 1, 0, 0, 0, 1723, 10474, 1, 0, 0, 0, 1725, 10482, + 1, 0, 0, 0, 1727, 10493, 1, 0, 0, 0, 1729, 10503, 1, 0, 0, 0, 1731, 10513, + 1, 0, 0, 0, 1733, 10520, 1, 0, 0, 0, 1735, 10528, 1, 0, 0, 0, 1737, 10540, + 1, 0, 0, 0, 1739, 10552, 1, 0, 0, 0, 1741, 10562, 1, 0, 0, 0, 1743, 10571, + 1, 0, 0, 0, 1745, 10580, 1, 0, 0, 0, 1747, 10584, 1, 0, 0, 0, 1749, 10591, + 1, 0, 0, 0, 1751, 10599, 1, 0, 0, 0, 1753, 10608, 1, 0, 0, 0, 1755, 10625, + 1, 0, 0, 0, 1757, 10634, 1, 0, 0, 0, 1759, 10641, 1, 0, 0, 0, 1761, 10645, + 1, 0, 0, 0, 1763, 10656, 1, 0, 0, 0, 1765, 10669, 1, 0, 0, 0, 1767, 10682, + 1, 0, 0, 0, 1769, 10688, 1, 0, 0, 0, 1771, 10700, 1, 0, 0, 0, 1773, 10706, + 1, 0, 0, 0, 1775, 10713, 1, 0, 0, 0, 1777, 10724, 1, 0, 0, 0, 1779, 10736, + 1, 0, 0, 0, 1781, 10746, 1, 0, 0, 0, 1783, 10760, 1, 0, 0, 0, 1785, 10777, + 1, 0, 0, 0, 1787, 10793, 1, 0, 0, 0, 1789, 10820, 1, 0, 0, 0, 1791, 10846, + 1, 0, 0, 0, 1793, 10863, 1, 0, 0, 0, 1795, 10879, 1, 0, 0, 0, 1797, 10889, + 1, 0, 0, 0, 1799, 10902, 1, 0, 0, 0, 1801, 10915, 1, 0, 0, 0, 1803, 10927, + 1, 0, 0, 0, 1805, 10938, 1, 0, 0, 0, 1807, 10947, 1, 0, 0, 0, 1809, 10955, + 1, 0, 0, 0, 1811, 10964, 1, 0, 0, 0, 1813, 10976, 1, 0, 0, 0, 1815, 10990, + 1, 0, 0, 0, 1817, 10994, 1, 0, 0, 0, 1819, 11001, 1, 0, 0, 0, 1821, 11012, + 1, 0, 0, 0, 1823, 11023, 1, 0, 0, 0, 1825, 11033, 1, 0, 0, 0, 1827, 11043, + 1, 0, 0, 0, 1829, 11049, 1, 0, 0, 0, 1831, 11063, 1, 0, 0, 0, 1833, 11074, + 1, 0, 0, 0, 1835, 11083, 1, 0, 0, 0, 1837, 11091, 1, 0, 0, 0, 1839, 11098, + 1, 0, 0, 0, 1841, 11107, 1, 0, 0, 0, 1843, 11120, 1, 0, 0, 0, 1845, 11128, + 1, 0, 0, 0, 1847, 11143, 1, 0, 0, 0, 1849, 11158, 1, 0, 0, 0, 1851, 11166, + 1, 0, 0, 0, 1853, 11179, 1, 0, 0, 0, 1855, 11194, 1, 0, 0, 0, 1857, 11200, + 1, 0, 0, 0, 1859, 11206, 1, 0, 0, 0, 1861, 11213, 1, 0, 0, 0, 1863, 11226, + 1, 0, 0, 0, 1865, 11238, 1, 0, 0, 0, 1867, 11257, 1, 0, 0, 0, 1869, 11275, + 1, 0, 0, 0, 1871, 11278, 1, 0, 0, 0, 1873, 11288, 1, 0, 0, 0, 1875, 11295, + 1, 0, 0, 0, 1877, 11299, 1, 0, 0, 0, 1879, 11305, 1, 0, 0, 0, 1881, 11310, + 1, 0, 0, 0, 1883, 11316, 1, 0, 0, 0, 1885, 11321, 1, 0, 0, 0, 1887, 11327, + 1, 0, 0, 0, 1889, 11336, 1, 0, 0, 0, 1891, 11345, 1, 0, 0, 0, 1893, 11354, + 1, 0, 0, 0, 1895, 11370, 1, 0, 0, 0, 1897, 11382, 1, 0, 0, 0, 1899, 11394, + 1, 0, 0, 0, 1901, 11403, 1, 0, 0, 0, 1903, 11417, 1, 0, 0, 0, 1905, 11429, + 1, 0, 0, 0, 1907, 11440, 1, 0, 0, 0, 1909, 11450, 1, 0, 0, 0, 1911, 11454, + 1, 0, 0, 0, 1913, 11468, 1, 0, 0, 0, 1915, 11481, 1, 0, 0, 0, 1917, 11491, + 1, 0, 0, 0, 1919, 11506, 1, 0, 0, 0, 1921, 11520, 1, 0, 0, 0, 1923, 11534, + 1, 0, 0, 0, 1925, 11547, 1, 0, 0, 0, 1927, 11571, 1, 0, 0, 0, 1929, 11594, + 1, 0, 0, 0, 1931, 11613, 1, 0, 0, 0, 1933, 11631, 1, 0, 0, 0, 1935, 11652, + 1, 0, 0, 0, 1937, 11672, 1, 0, 0, 0, 1939, 11683, 1, 0, 0, 0, 1941, 11690, + 1, 0, 0, 0, 1943, 11704, 1, 0, 0, 0, 1945, 11721, 1, 0, 0, 0, 1947, 11731, + 1, 0, 0, 0, 1949, 11735, 1, 0, 0, 0, 1951, 11748, 1, 0, 0, 0, 1953, 11752, + 1, 0, 0, 0, 1955, 11761, 1, 0, 0, 0, 1957, 11772, 1, 0, 0, 0, 1959, 11784, + 1, 0, 0, 0, 1961, 11787, 1, 0, 0, 0, 1963, 11801, 1, 0, 0, 0, 1965, 11814, + 1, 0, 0, 0, 1967, 11821, 1, 0, 0, 0, 1969, 11834, 1, 0, 0, 0, 1971, 11846, + 1, 0, 0, 0, 1973, 11862, 1, 0, 0, 0, 1975, 11877, 1, 0, 0, 0, 1977, 11881, + 1, 0, 0, 0, 1979, 11887, 1, 0, 0, 0, 1981, 11893, 1, 0, 0, 0, 1983, 11901, + 1, 0, 0, 0, 1985, 11906, 1, 0, 0, 0, 1987, 11913, 1, 0, 0, 0, 1989, 11926, + 1, 0, 0, 0, 1991, 11939, 1, 0, 0, 0, 1993, 11947, 1, 0, 0, 0, 1995, 11953, + 1, 0, 0, 0, 1997, 11963, 1, 0, 0, 0, 1999, 11968, 1, 0, 0, 0, 2001, 11974, + 1, 0, 0, 0, 2003, 11986, 1, 0, 0, 0, 2005, 12013, 1, 0, 0, 0, 2007, 12026, + 1, 0, 0, 0, 2009, 12030, 1, 0, 0, 0, 2011, 12035, 1, 0, 0, 0, 2013, 12040, + 1, 0, 0, 0, 2015, 12052, 1, 0, 0, 0, 2017, 12057, 1, 0, 0, 0, 2019, 12061, + 1, 0, 0, 0, 2021, 12067, 1, 0, 0, 0, 2023, 12075, 1, 0, 0, 0, 2025, 12103, + 1, 0, 0, 0, 2027, 12108, 1, 0, 0, 0, 2029, 12113, 1, 0, 0, 0, 2031, 12124, + 1, 0, 0, 0, 2033, 12131, 1, 0, 0, 0, 2035, 12143, 1, 0, 0, 0, 2037, 12151, + 1, 0, 0, 0, 2039, 12163, 1, 0, 0, 0, 2041, 12173, 1, 0, 0, 0, 2043, 12182, + 1, 0, 0, 0, 2045, 12191, 1, 0, 0, 0, 2047, 12201, 1, 0, 0, 0, 2049, 12213, + 1, 0, 0, 0, 2051, 12225, 1, 0, 0, 0, 2053, 12236, 1, 0, 0, 0, 2055, 12250, + 1, 0, 0, 0, 2057, 12263, 1, 0, 0, 0, 2059, 12275, 1, 0, 0, 0, 2061, 12287, + 1, 0, 0, 0, 2063, 12299, 1, 0, 0, 0, 2065, 12311, 1, 0, 0, 0, 2067, 12321, + 1, 0, 0, 0, 2069, 12337, 1, 0, 0, 0, 2071, 12357, 1, 0, 0, 0, 2073, 12376, + 1, 0, 0, 0, 2075, 12395, 1, 0, 0, 0, 2077, 12425, 1, 0, 0, 0, 2079, 12454, + 1, 0, 0, 0, 2081, 12474, 1, 0, 0, 0, 2083, 12493, 1, 0, 0, 0, 2085, 12506, + 1, 0, 0, 0, 2087, 12522, 1, 0, 0, 0, 2089, 12538, 1, 0, 0, 0, 2091, 12553, + 1, 0, 0, 0, 2093, 12570, 1, 0, 0, 0, 2095, 12586, 1, 0, 0, 0, 2097, 12600, + 1, 0, 0, 0, 2099, 12612, 1, 0, 0, 0, 2101, 12623, 1, 0, 0, 0, 2103, 12635, + 1, 0, 0, 0, 2105, 12651, 1, 0, 0, 0, 2107, 12666, 1, 0, 0, 0, 2109, 12688, + 1, 0, 0, 0, 2111, 12709, 1, 0, 0, 0, 2113, 12726, 1, 0, 0, 0, 2115, 12745, + 1, 0, 0, 0, 2117, 12765, 1, 0, 0, 0, 2119, 12778, 1, 0, 0, 0, 2121, 12790, + 1, 0, 0, 0, 2123, 12807, 1, 0, 0, 0, 2125, 12823, 1, 0, 0, 0, 2127, 12833, + 1, 0, 0, 0, 2129, 12849, 1, 0, 0, 0, 2131, 12864, 1, 0, 0, 0, 2133, 12883, + 1, 0, 0, 0, 2135, 12901, 1, 0, 0, 0, 2137, 12909, 1, 0, 0, 0, 2139, 12923, + 1, 0, 0, 0, 2141, 12940, 1, 0, 0, 0, 2143, 12951, 1, 0, 0, 0, 2145, 12960, + 1, 0, 0, 0, 2147, 12970, 1, 0, 0, 0, 2149, 12975, 1, 0, 0, 0, 2151, 12980, + 1, 0, 0, 0, 2153, 12997, 1, 0, 0, 0, 2155, 13005, 1, 0, 0, 0, 2157, 13021, + 1, 0, 0, 0, 2159, 13029, 1, 0, 0, 0, 2161, 13041, 1, 0, 0, 0, 2163, 13045, + 1, 0, 0, 0, 2165, 13054, 1, 0, 0, 0, 2167, 13067, 1, 0, 0, 0, 2169, 13081, + 1, 0, 0, 0, 2171, 13093, 1, 0, 0, 0, 2173, 13105, 1, 0, 0, 0, 2175, 13113, + 1, 0, 0, 0, 2177, 13123, 1, 0, 0, 0, 2179, 13131, 1, 0, 0, 0, 2181, 13142, + 1, 0, 0, 0, 2183, 13162, 1, 0, 0, 0, 2185, 13168, 1, 0, 0, 0, 2187, 13179, + 1, 0, 0, 0, 2189, 13199, 1, 0, 0, 0, 2191, 13205, 1, 0, 0, 0, 2193, 13220, + 1, 0, 0, 0, 2195, 13230, 1, 0, 0, 0, 2197, 13236, 1, 0, 0, 0, 2199, 13241, + 1, 0, 0, 0, 2201, 13252, 1, 0, 0, 0, 2203, 13279, 1, 0, 0, 0, 2205, 13290, + 1, 0, 0, 0, 2207, 13307, 1, 0, 0, 0, 2209, 13315, 1, 0, 0, 0, 2211, 13349, + 1, 0, 0, 0, 2213, 13357, 1, 0, 0, 0, 2215, 13368, 1, 0, 0, 0, 2217, 13382, + 1, 0, 0, 0, 2219, 13389, 1, 0, 0, 0, 2221, 13398, 1, 0, 0, 0, 2223, 13400, + 1, 0, 0, 0, 2225, 13402, 1, 0, 0, 0, 2227, 13405, 1, 0, 0, 0, 2229, 13408, + 1, 0, 0, 0, 2231, 13411, 1, 0, 0, 0, 2233, 13414, 1, 0, 0, 0, 2235, 13417, + 1, 0, 0, 0, 2237, 13420, 1, 0, 0, 0, 2239, 13423, 1, 0, 0, 0, 2241, 13426, + 1, 0, 0, 0, 2243, 13429, 1, 0, 0, 0, 2245, 13431, 1, 0, 0, 0, 2247, 13433, + 1, 0, 0, 0, 2249, 13435, 1, 0, 0, 0, 2251, 13437, 1, 0, 0, 0, 2253, 13439, + 1, 0, 0, 0, 2255, 13443, 1, 0, 0, 0, 2257, 13447, 1, 0, 0, 0, 2259, 13449, + 1, 0, 0, 0, 2261, 13451, 1, 0, 0, 0, 2263, 13453, 1, 0, 0, 0, 2265, 13455, + 1, 0, 0, 0, 2267, 13457, 1, 0, 0, 0, 2269, 13459, 1, 0, 0, 0, 2271, 13461, + 1, 0, 0, 0, 2273, 13463, 1, 0, 0, 0, 2275, 13465, 1, 0, 0, 0, 2277, 13467, + 1, 0, 0, 0, 2279, 13469, 1, 0, 0, 0, 2281, 13471, 1, 0, 0, 0, 2283, 13473, + 1, 0, 0, 0, 2285, 13475, 1, 0, 0, 0, 2287, 13477, 1, 0, 0, 0, 2289, 13479, + 1, 0, 0, 0, 2291, 13481, 1, 0, 0, 0, 2293, 13483, 1, 0, 0, 0, 2295, 13485, + 1, 0, 0, 0, 2297, 13487, 1, 0, 0, 0, 2299, 13492, 1, 0, 0, 0, 2301, 13494, + 1, 0, 0, 0, 2303, 13499, 1, 0, 0, 0, 2305, 13505, 1, 0, 0, 0, 2307, 13511, + 1, 0, 0, 0, 2309, 13514, 1, 0, 0, 0, 2311, 13537, 1, 0, 0, 0, 2313, 13580, + 1, 0, 0, 0, 2315, 13582, 1, 0, 0, 0, 2317, 13585, 1, 0, 0, 0, 2319, 13587, + 1, 0, 0, 0, 2321, 13590, 1, 0, 0, 0, 2323, 13593, 1, 0, 0, 0, 2325, 13595, + 1, 0, 0, 0, 2327, 13597, 1, 0, 0, 0, 2329, 13600, 1, 0, 0, 0, 2331, 13609, + 1, 0, 0, 0, 2333, 13660, 1, 0, 0, 0, 2335, 13662, 1, 0, 0, 0, 2337, 13674, + 1, 0, 0, 0, 2339, 13688, 1, 0, 0, 0, 2341, 13701, 1, 0, 0, 0, 2343, 13714, + 1, 0, 0, 0, 2345, 13725, 1, 0, 0, 0, 2347, 13727, 1, 0, 0, 0, 2349, 13729, + 1, 0, 0, 0, 2351, 13768, 1, 0, 0, 0, 2353, 13770, 1, 0, 0, 0, 2355, 2357, + 7, 0, 0, 0, 2356, 2355, 1, 0, 0, 0, 2357, 2358, 1, 0, 0, 0, 2358, 2356, + 1, 0, 0, 0, 2358, 2359, 1, 0, 0, 0, 2359, 2360, 1, 0, 0, 0, 2360, 2361, + 6, 0, 0, 0, 2361, 2, 1, 0, 0, 0, 2362, 2363, 5, 47, 0, 0, 2363, 2364, 5, + 42, 0, 0, 2364, 2365, 5, 33, 0, 0, 2365, 2367, 1, 0, 0, 0, 2366, 2368, + 9, 0, 0, 0, 2367, 2366, 1, 0, 0, 0, 2368, 2369, 1, 0, 0, 0, 2369, 2370, + 1, 0, 0, 0, 2369, 2367, 1, 0, 0, 0, 2370, 2371, 1, 0, 0, 0, 2371, 2372, + 5, 42, 0, 0, 2372, 2373, 5, 47, 0, 0, 2373, 2374, 1, 0, 0, 0, 2374, 2375, + 6, 1, 1, 0, 2375, 4, 1, 0, 0, 0, 2376, 2377, 5, 47, 0, 0, 2377, 2378, 5, + 42, 0, 0, 2378, 2382, 1, 0, 0, 0, 2379, 2381, 9, 0, 0, 0, 2380, 2379, 1, + 0, 0, 0, 2381, 2384, 1, 0, 0, 0, 2382, 2383, 1, 0, 0, 0, 2382, 2380, 1, + 0, 0, 0, 2383, 2385, 1, 0, 0, 0, 2384, 2382, 1, 0, 0, 0, 2385, 2386, 5, + 42, 0, 0, 2386, 2387, 5, 47, 0, 0, 2387, 2388, 1, 0, 0, 0, 2388, 2389, + 6, 2, 0, 0, 2389, 6, 1, 0, 0, 0, 2390, 2391, 5, 45, 0, 0, 2391, 2392, 5, + 45, 0, 0, 2392, 2396, 1, 0, 0, 0, 2393, 2395, 7, 1, 0, 0, 2394, 2393, 1, + 0, 0, 0, 2395, 2398, 1, 0, 0, 0, 2396, 2394, 1, 0, 0, 0, 2396, 2397, 1, + 0, 0, 0, 2397, 2401, 1, 0, 0, 0, 2398, 2396, 1, 0, 0, 0, 2399, 2401, 5, + 35, 0, 0, 2400, 2390, 1, 0, 0, 0, 2400, 2399, 1, 0, 0, 0, 2401, 2405, 1, + 0, 0, 0, 2402, 2404, 8, 2, 0, 0, 2403, 2402, 1, 0, 0, 0, 2404, 2407, 1, + 0, 0, 0, 2405, 2403, 1, 0, 0, 0, 2405, 2406, 1, 0, 0, 0, 2406, 2413, 1, + 0, 0, 0, 2407, 2405, 1, 0, 0, 0, 2408, 2410, 5, 13, 0, 0, 2409, 2408, 1, + 0, 0, 0, 2409, 2410, 1, 0, 0, 0, 2410, 2411, 1, 0, 0, 0, 2411, 2414, 5, + 10, 0, 0, 2412, 2414, 5, 0, 0, 1, 2413, 2409, 1, 0, 0, 0, 2413, 2412, 1, + 0, 0, 0, 2414, 2426, 1, 0, 0, 0, 2415, 2416, 5, 45, 0, 0, 2416, 2417, 5, + 45, 0, 0, 2417, 2423, 1, 0, 0, 0, 2418, 2420, 5, 13, 0, 0, 2419, 2418, + 1, 0, 0, 0, 2419, 2420, 1, 0, 0, 0, 2420, 2421, 1, 0, 0, 0, 2421, 2424, + 5, 10, 0, 0, 2422, 2424, 5, 0, 0, 1, 2423, 2419, 1, 0, 0, 0, 2423, 2422, + 1, 0, 0, 0, 2424, 2426, 1, 0, 0, 0, 2425, 2400, 1, 0, 0, 0, 2425, 2415, + 1, 0, 0, 0, 2426, 2427, 1, 0, 0, 0, 2427, 2428, 6, 3, 0, 0, 2428, 8, 1, + 0, 0, 0, 2429, 2430, 7, 3, 0, 0, 2430, 2431, 7, 4, 0, 0, 2431, 2432, 7, + 4, 0, 0, 2432, 10, 1, 0, 0, 0, 2433, 2434, 7, 3, 0, 0, 2434, 2435, 7, 5, + 0, 0, 2435, 2436, 7, 5, 0, 0, 2436, 12, 1, 0, 0, 0, 2437, 2438, 7, 3, 0, + 0, 2438, 2439, 7, 5, 0, 0, 2439, 2440, 7, 6, 0, 0, 2440, 2441, 7, 7, 0, + 0, 2441, 2442, 7, 8, 0, 0, 2442, 14, 1, 0, 0, 0, 2443, 2444, 7, 3, 0, 0, + 2444, 2445, 7, 5, 0, 0, 2445, 2446, 7, 9, 0, 0, 2446, 2447, 7, 3, 0, 0, + 2447, 2448, 7, 10, 0, 0, 2448, 2449, 7, 11, 0, 0, 2449, 16, 1, 0, 0, 0, + 2450, 2451, 7, 3, 0, 0, 2451, 2452, 7, 12, 0, 0, 2452, 2453, 7, 3, 0, 0, + 2453, 2454, 7, 5, 0, 0, 2454, 2455, 7, 10, 0, 0, 2455, 2456, 7, 13, 0, + 0, 2456, 2457, 7, 7, 0, 0, 2457, 18, 1, 0, 0, 0, 2458, 2459, 7, 3, 0, 0, + 2459, 2460, 7, 12, 0, 0, 2460, 2461, 7, 4, 0, 0, 2461, 20, 1, 0, 0, 0, + 2462, 2463, 7, 3, 0, 0, 2463, 2464, 7, 8, 0, 0, 2464, 2465, 7, 8, 0, 0, + 2465, 2466, 7, 3, 0, 0, 2466, 2467, 7, 10, 0, 0, 2467, 22, 1, 0, 0, 0, + 2468, 2469, 7, 3, 0, 0, 2469, 2470, 7, 11, 0, 0, 2470, 24, 1, 0, 0, 0, + 2471, 2472, 7, 3, 0, 0, 2472, 2473, 7, 11, 0, 0, 2473, 2474, 7, 14, 0, + 0, 2474, 26, 1, 0, 0, 0, 2475, 2476, 7, 3, 0, 0, 2476, 2477, 7, 6, 0, 0, + 2477, 2478, 7, 6, 0, 0, 2478, 2479, 7, 8, 0, 0, 2479, 2480, 7, 15, 0, 0, + 2480, 2481, 7, 16, 0, 0, 2481, 2482, 7, 17, 0, 0, 2482, 2483, 7, 6, 0, + 0, 2483, 2484, 7, 7, 0, 0, 2484, 28, 1, 0, 0, 0, 2485, 2486, 7, 16, 0, + 0, 2486, 2487, 7, 7, 0, 0, 2487, 2488, 7, 18, 0, 0, 2488, 2489, 7, 19, + 0, 0, 2489, 2490, 7, 8, 0, 0, 2490, 2491, 7, 7, 0, 0, 2491, 30, 1, 0, 0, + 0, 2492, 2493, 7, 16, 0, 0, 2493, 2494, 7, 7, 0, 0, 2494, 2495, 7, 6, 0, + 0, 2495, 2496, 7, 9, 0, 0, 2496, 2497, 7, 7, 0, 0, 2497, 2498, 7, 7, 0, + 0, 2498, 2499, 7, 12, 0, 0, 2499, 32, 1, 0, 0, 0, 2500, 2501, 7, 16, 0, + 0, 2501, 2502, 7, 19, 0, 0, 2502, 2503, 7, 6, 0, 0, 2503, 2504, 7, 20, + 0, 0, 2504, 34, 1, 0, 0, 0, 2505, 2506, 7, 16, 0, 0, 2506, 2507, 7, 17, + 0, 0, 2507, 2508, 7, 14, 0, 0, 2508, 2509, 7, 21, 0, 0, 2509, 2510, 7, + 7, 0, 0, 2510, 2511, 7, 6, 0, 0, 2511, 2512, 7, 11, 0, 0, 2512, 36, 1, + 0, 0, 0, 2513, 2514, 7, 16, 0, 0, 2514, 2515, 7, 10, 0, 0, 2515, 38, 1, + 0, 0, 0, 2516, 2517, 7, 14, 0, 0, 2517, 2518, 7, 3, 0, 0, 2518, 2519, 7, + 5, 0, 0, 2519, 2520, 7, 5, 0, 0, 2520, 40, 1, 0, 0, 0, 2521, 2522, 7, 14, + 0, 0, 2522, 2523, 7, 3, 0, 0, 2523, 2524, 7, 11, 0, 0, 2524, 2525, 7, 14, + 0, 0, 2525, 2526, 7, 3, 0, 0, 2526, 2527, 7, 4, 0, 0, 2527, 2528, 7, 7, + 0, 0, 2528, 42, 1, 0, 0, 0, 2529, 2530, 7, 14, 0, 0, 2530, 2531, 7, 3, + 0, 0, 2531, 2532, 7, 11, 0, 0, 2532, 2533, 7, 7, 0, 0, 2533, 44, 1, 0, + 0, 0, 2534, 2535, 7, 14, 0, 0, 2535, 2536, 7, 3, 0, 0, 2536, 2537, 7, 11, + 0, 0, 2537, 2538, 7, 6, 0, 0, 2538, 46, 1, 0, 0, 0, 2539, 2540, 7, 14, + 0, 0, 2540, 2541, 7, 20, 0, 0, 2541, 2542, 7, 3, 0, 0, 2542, 2543, 7, 12, + 0, 0, 2543, 2544, 7, 22, 0, 0, 2544, 2545, 7, 7, 0, 0, 2545, 48, 1, 0, + 0, 0, 2546, 2547, 7, 14, 0, 0, 2547, 2548, 7, 20, 0, 0, 2548, 2549, 7, + 3, 0, 0, 2549, 2550, 7, 8, 0, 0, 2550, 2551, 7, 3, 0, 0, 2551, 2552, 7, + 14, 0, 0, 2552, 2553, 7, 6, 0, 0, 2553, 2554, 7, 7, 0, 0, 2554, 2555, 7, + 8, 0, 0, 2555, 50, 1, 0, 0, 0, 2556, 2557, 7, 14, 0, 0, 2557, 2558, 7, + 20, 0, 0, 2558, 2559, 7, 7, 0, 0, 2559, 2560, 7, 14, 0, 0, 2560, 2561, + 7, 21, 0, 0, 2561, 52, 1, 0, 0, 0, 2562, 2563, 7, 14, 0, 0, 2563, 2564, + 7, 19, 0, 0, 2564, 2565, 7, 5, 0, 0, 2565, 2566, 7, 5, 0, 0, 2566, 2567, + 7, 3, 0, 0, 2567, 2568, 7, 6, 0, 0, 2568, 2569, 7, 7, 0, 0, 2569, 54, 1, + 0, 0, 0, 2570, 2571, 7, 14, 0, 0, 2571, 2572, 7, 19, 0, 0, 2572, 2573, + 7, 5, 0, 0, 2573, 2574, 7, 17, 0, 0, 2574, 2575, 7, 23, 0, 0, 2575, 2576, + 7, 12, 0, 0, 2576, 56, 1, 0, 0, 0, 2577, 2578, 7, 14, 0, 0, 2578, 2579, + 7, 19, 0, 0, 2579, 2580, 7, 12, 0, 0, 2580, 2581, 7, 4, 0, 0, 2581, 2582, + 7, 15, 0, 0, 2582, 2583, 7, 6, 0, 0, 2583, 2584, 7, 15, 0, 0, 2584, 2585, + 7, 19, 0, 0, 2585, 2586, 7, 12, 0, 0, 2586, 58, 1, 0, 0, 0, 2587, 2588, + 7, 14, 0, 0, 2588, 2589, 7, 19, 0, 0, 2589, 2590, 7, 12, 0, 0, 2590, 2591, + 7, 11, 0, 0, 2591, 2592, 7, 6, 0, 0, 2592, 2593, 7, 8, 0, 0, 2593, 2594, + 7, 3, 0, 0, 2594, 2595, 7, 15, 0, 0, 2595, 2596, 7, 12, 0, 0, 2596, 2597, + 7, 6, 0, 0, 2597, 60, 1, 0, 0, 0, 2598, 2599, 7, 14, 0, 0, 2599, 2600, + 7, 19, 0, 0, 2600, 2601, 7, 12, 0, 0, 2601, 2602, 7, 6, 0, 0, 2602, 2603, + 7, 15, 0, 0, 2603, 2604, 7, 12, 0, 0, 2604, 2605, 7, 17, 0, 0, 2605, 2606, + 7, 7, 0, 0, 2606, 62, 1, 0, 0, 0, 2607, 2608, 7, 14, 0, 0, 2608, 2609, + 7, 19, 0, 0, 2609, 2610, 7, 12, 0, 0, 2610, 2611, 7, 24, 0, 0, 2611, 2612, + 7, 7, 0, 0, 2612, 2613, 7, 8, 0, 0, 2613, 2614, 7, 6, 0, 0, 2614, 64, 1, + 0, 0, 0, 2615, 2616, 7, 14, 0, 0, 2616, 2617, 7, 8, 0, 0, 2617, 2618, 7, + 7, 0, 0, 2618, 2619, 7, 3, 0, 0, 2619, 2620, 7, 6, 0, 0, 2620, 2621, 7, + 7, 0, 0, 2621, 66, 1, 0, 0, 0, 2622, 2623, 7, 14, 0, 0, 2623, 2624, 7, + 8, 0, 0, 2624, 2625, 7, 19, 0, 0, 2625, 2626, 7, 11, 0, 0, 2626, 2627, + 7, 11, 0, 0, 2627, 68, 1, 0, 0, 0, 2628, 2629, 7, 14, 0, 0, 2629, 2630, + 7, 17, 0, 0, 2630, 2631, 7, 8, 0, 0, 2631, 2632, 7, 8, 0, 0, 2632, 2633, + 7, 7, 0, 0, 2633, 2634, 7, 12, 0, 0, 2634, 2635, 7, 6, 0, 0, 2635, 70, + 1, 0, 0, 0, 2636, 2637, 7, 14, 0, 0, 2637, 2638, 7, 17, 0, 0, 2638, 2639, + 7, 8, 0, 0, 2639, 2640, 7, 8, 0, 0, 2640, 2641, 7, 7, 0, 0, 2641, 2642, + 7, 12, 0, 0, 2642, 2643, 7, 6, 0, 0, 2643, 2644, 5, 95, 0, 0, 2644, 2645, + 7, 8, 0, 0, 2645, 2646, 7, 19, 0, 0, 2646, 2647, 7, 5, 0, 0, 2647, 2648, + 7, 7, 0, 0, 2648, 72, 1, 0, 0, 0, 2649, 2650, 7, 14, 0, 0, 2650, 2651, + 7, 17, 0, 0, 2651, 2652, 7, 8, 0, 0, 2652, 2653, 7, 8, 0, 0, 2653, 2654, + 7, 7, 0, 0, 2654, 2655, 7, 12, 0, 0, 2655, 2656, 7, 6, 0, 0, 2656, 2657, + 5, 95, 0, 0, 2657, 2658, 7, 17, 0, 0, 2658, 2659, 7, 11, 0, 0, 2659, 2660, + 7, 7, 0, 0, 2660, 2661, 7, 8, 0, 0, 2661, 74, 1, 0, 0, 0, 2662, 2663, 7, + 14, 0, 0, 2663, 2664, 7, 17, 0, 0, 2664, 2665, 7, 8, 0, 0, 2665, 2666, + 7, 11, 0, 0, 2666, 2667, 7, 19, 0, 0, 2667, 2668, 7, 8, 0, 0, 2668, 76, + 1, 0, 0, 0, 2669, 2670, 7, 4, 0, 0, 2670, 2671, 7, 3, 0, 0, 2671, 2672, + 7, 6, 0, 0, 2672, 2673, 7, 3, 0, 0, 2673, 2674, 7, 16, 0, 0, 2674, 2675, + 7, 3, 0, 0, 2675, 2676, 7, 11, 0, 0, 2676, 2677, 7, 7, 0, 0, 2677, 78, + 1, 0, 0, 0, 2678, 2679, 7, 4, 0, 0, 2679, 2680, 7, 3, 0, 0, 2680, 2681, + 7, 6, 0, 0, 2681, 2682, 7, 3, 0, 0, 2682, 2683, 7, 16, 0, 0, 2683, 2684, + 7, 3, 0, 0, 2684, 2685, 7, 11, 0, 0, 2685, 2686, 7, 7, 0, 0, 2686, 2687, + 7, 11, 0, 0, 2687, 80, 1, 0, 0, 0, 2688, 2689, 7, 4, 0, 0, 2689, 2690, + 7, 7, 0, 0, 2690, 2691, 7, 14, 0, 0, 2691, 2692, 7, 5, 0, 0, 2692, 2693, + 7, 3, 0, 0, 2693, 2694, 7, 8, 0, 0, 2694, 2695, 7, 7, 0, 0, 2695, 82, 1, + 0, 0, 0, 2696, 2697, 7, 4, 0, 0, 2697, 2698, 7, 7, 0, 0, 2698, 2699, 7, + 18, 0, 0, 2699, 2700, 7, 3, 0, 0, 2700, 2701, 7, 17, 0, 0, 2701, 2702, + 7, 5, 0, 0, 2702, 2703, 7, 6, 0, 0, 2703, 84, 1, 0, 0, 0, 2704, 2705, 7, + 4, 0, 0, 2705, 2706, 7, 7, 0, 0, 2706, 2707, 7, 5, 0, 0, 2707, 2708, 7, + 3, 0, 0, 2708, 2709, 7, 10, 0, 0, 2709, 2710, 7, 7, 0, 0, 2710, 2711, 7, + 4, 0, 0, 2711, 86, 1, 0, 0, 0, 2712, 2713, 7, 4, 0, 0, 2713, 2714, 7, 7, + 0, 0, 2714, 2715, 7, 5, 0, 0, 2715, 2716, 7, 7, 0, 0, 2716, 2717, 7, 6, + 0, 0, 2717, 2718, 7, 7, 0, 0, 2718, 88, 1, 0, 0, 0, 2719, 2720, 7, 4, 0, + 0, 2720, 2721, 7, 7, 0, 0, 2721, 2722, 7, 11, 0, 0, 2722, 2723, 7, 14, + 0, 0, 2723, 90, 1, 0, 0, 0, 2724, 2725, 7, 4, 0, 0, 2725, 2726, 7, 7, 0, + 0, 2726, 2727, 7, 11, 0, 0, 2727, 2728, 7, 14, 0, 0, 2728, 2729, 7, 8, + 0, 0, 2729, 2730, 7, 15, 0, 0, 2730, 2731, 7, 16, 0, 0, 2731, 2732, 7, + 7, 0, 0, 2732, 92, 1, 0, 0, 0, 2733, 2734, 7, 4, 0, 0, 2734, 2735, 7, 7, + 0, 0, 2735, 2736, 7, 6, 0, 0, 2736, 2737, 7, 7, 0, 0, 2737, 2738, 7, 8, + 0, 0, 2738, 2739, 7, 23, 0, 0, 2739, 2740, 7, 15, 0, 0, 2740, 2741, 7, + 12, 0, 0, 2741, 2742, 7, 15, 0, 0, 2742, 2743, 7, 11, 0, 0, 2743, 2744, + 7, 6, 0, 0, 2744, 2745, 7, 15, 0, 0, 2745, 2746, 7, 14, 0, 0, 2746, 94, + 1, 0, 0, 0, 2747, 2748, 7, 4, 0, 0, 2748, 2749, 7, 15, 0, 0, 2749, 2750, + 7, 3, 0, 0, 2750, 2751, 7, 22, 0, 0, 2751, 2752, 7, 12, 0, 0, 2752, 2753, + 7, 19, 0, 0, 2753, 2754, 7, 11, 0, 0, 2754, 2755, 7, 6, 0, 0, 2755, 2756, + 7, 15, 0, 0, 2756, 2757, 7, 14, 0, 0, 2757, 2758, 7, 11, 0, 0, 2758, 96, + 1, 0, 0, 0, 2759, 2760, 7, 4, 0, 0, 2760, 2761, 7, 15, 0, 0, 2761, 2762, + 7, 11, 0, 0, 2762, 2763, 7, 6, 0, 0, 2763, 2764, 7, 15, 0, 0, 2764, 2765, + 7, 12, 0, 0, 2765, 2766, 7, 14, 0, 0, 2766, 2767, 7, 6, 0, 0, 2767, 98, + 1, 0, 0, 0, 2768, 2769, 7, 4, 0, 0, 2769, 2770, 7, 15, 0, 0, 2770, 2771, + 7, 11, 0, 0, 2771, 2772, 7, 6, 0, 0, 2772, 2773, 7, 15, 0, 0, 2773, 2774, + 7, 12, 0, 0, 2774, 2775, 7, 14, 0, 0, 2775, 2776, 7, 6, 0, 0, 2776, 2777, + 7, 8, 0, 0, 2777, 2778, 7, 19, 0, 0, 2778, 2779, 7, 9, 0, 0, 2779, 100, + 1, 0, 0, 0, 2780, 2781, 7, 4, 0, 0, 2781, 2782, 7, 8, 0, 0, 2782, 2783, + 7, 19, 0, 0, 2783, 2784, 7, 25, 0, 0, 2784, 102, 1, 0, 0, 0, 2785, 2786, + 7, 7, 0, 0, 2786, 2787, 7, 3, 0, 0, 2787, 2788, 7, 14, 0, 0, 2788, 2789, + 7, 20, 0, 0, 2789, 104, 1, 0, 0, 0, 2790, 2791, 7, 7, 0, 0, 2791, 2792, + 7, 5, 0, 0, 2792, 2793, 7, 11, 0, 0, 2793, 2794, 7, 7, 0, 0, 2794, 106, + 1, 0, 0, 0, 2795, 2796, 7, 7, 0, 0, 2796, 2797, 7, 5, 0, 0, 2797, 2798, + 7, 11, 0, 0, 2798, 2799, 7, 7, 0, 0, 2799, 2800, 7, 15, 0, 0, 2800, 2801, + 7, 18, 0, 0, 2801, 108, 1, 0, 0, 0, 2802, 2803, 7, 7, 0, 0, 2803, 2804, + 7, 23, 0, 0, 2804, 2805, 7, 25, 0, 0, 2805, 2806, 7, 6, 0, 0, 2806, 2807, + 7, 10, 0, 0, 2807, 110, 1, 0, 0, 0, 2808, 2809, 7, 7, 0, 0, 2809, 2810, + 7, 12, 0, 0, 2810, 2811, 7, 14, 0, 0, 2811, 2812, 7, 5, 0, 0, 2812, 2813, + 7, 19, 0, 0, 2813, 2814, 7, 11, 0, 0, 2814, 2815, 7, 7, 0, 0, 2815, 2816, + 7, 4, 0, 0, 2816, 112, 1, 0, 0, 0, 2817, 2818, 7, 7, 0, 0, 2818, 2819, + 7, 12, 0, 0, 2819, 2820, 7, 18, 0, 0, 2820, 2821, 7, 19, 0, 0, 2821, 2822, + 7, 8, 0, 0, 2822, 2823, 7, 14, 0, 0, 2823, 2824, 7, 7, 0, 0, 2824, 2825, + 7, 4, 0, 0, 2825, 114, 1, 0, 0, 0, 2826, 2827, 7, 7, 0, 0, 2827, 2828, + 7, 11, 0, 0, 2828, 2829, 7, 14, 0, 0, 2829, 2830, 7, 3, 0, 0, 2830, 2831, + 7, 25, 0, 0, 2831, 2832, 7, 7, 0, 0, 2832, 2833, 7, 4, 0, 0, 2833, 116, + 1, 0, 0, 0, 2834, 2835, 7, 7, 0, 0, 2835, 2836, 7, 26, 0, 0, 2836, 2837, + 7, 14, 0, 0, 2837, 2838, 7, 7, 0, 0, 2838, 2839, 7, 25, 0, 0, 2839, 2840, + 7, 6, 0, 0, 2840, 118, 1, 0, 0, 0, 2841, 2842, 7, 7, 0, 0, 2842, 2843, + 7, 26, 0, 0, 2843, 2844, 7, 15, 0, 0, 2844, 2845, 7, 11, 0, 0, 2845, 2846, + 7, 6, 0, 0, 2846, 2847, 7, 11, 0, 0, 2847, 120, 1, 0, 0, 0, 2848, 2849, + 7, 7, 0, 0, 2849, 2850, 7, 26, 0, 0, 2850, 2851, 7, 15, 0, 0, 2851, 2852, + 7, 6, 0, 0, 2852, 122, 1, 0, 0, 0, 2853, 2854, 7, 7, 0, 0, 2854, 2855, + 7, 26, 0, 0, 2855, 2856, 7, 25, 0, 0, 2856, 2857, 7, 5, 0, 0, 2857, 2858, + 7, 3, 0, 0, 2858, 2859, 7, 15, 0, 0, 2859, 2860, 7, 12, 0, 0, 2860, 124, + 1, 0, 0, 0, 2861, 2862, 7, 18, 0, 0, 2862, 2863, 7, 3, 0, 0, 2863, 2864, + 7, 5, 0, 0, 2864, 2865, 7, 11, 0, 0, 2865, 2866, 7, 7, 0, 0, 2866, 126, + 1, 0, 0, 0, 2867, 2868, 7, 18, 0, 0, 2868, 2869, 7, 7, 0, 0, 2869, 2870, + 7, 6, 0, 0, 2870, 2871, 7, 14, 0, 0, 2871, 2872, 7, 20, 0, 0, 2872, 128, + 1, 0, 0, 0, 2873, 2874, 7, 18, 0, 0, 2874, 2875, 7, 19, 0, 0, 2875, 2876, + 7, 8, 0, 0, 2876, 130, 1, 0, 0, 0, 2877, 2878, 7, 18, 0, 0, 2878, 2879, + 7, 19, 0, 0, 2879, 2880, 7, 8, 0, 0, 2880, 2881, 7, 14, 0, 0, 2881, 2882, + 7, 7, 0, 0, 2882, 132, 1, 0, 0, 0, 2883, 2884, 7, 18, 0, 0, 2884, 2885, + 7, 19, 0, 0, 2885, 2886, 7, 8, 0, 0, 2886, 2887, 7, 7, 0, 0, 2887, 2888, + 7, 15, 0, 0, 2888, 2889, 7, 22, 0, 0, 2889, 2890, 7, 12, 0, 0, 2890, 134, + 1, 0, 0, 0, 2891, 2892, 7, 18, 0, 0, 2892, 2893, 7, 8, 0, 0, 2893, 2894, + 7, 19, 0, 0, 2894, 2895, 7, 23, 0, 0, 2895, 136, 1, 0, 0, 0, 2896, 2897, + 7, 18, 0, 0, 2897, 2898, 7, 17, 0, 0, 2898, 2899, 7, 5, 0, 0, 2899, 2900, + 7, 5, 0, 0, 2900, 2901, 7, 6, 0, 0, 2901, 2902, 7, 7, 0, 0, 2902, 2903, + 7, 26, 0, 0, 2903, 2904, 7, 6, 0, 0, 2904, 138, 1, 0, 0, 0, 2905, 2906, + 7, 22, 0, 0, 2906, 2907, 7, 7, 0, 0, 2907, 2908, 7, 12, 0, 0, 2908, 2909, + 7, 7, 0, 0, 2909, 2910, 7, 8, 0, 0, 2910, 2911, 7, 3, 0, 0, 2911, 2912, + 7, 6, 0, 0, 2912, 2913, 7, 7, 0, 0, 2913, 2914, 7, 4, 0, 0, 2914, 140, + 1, 0, 0, 0, 2915, 2916, 7, 22, 0, 0, 2916, 2917, 7, 7, 0, 0, 2917, 2918, + 7, 6, 0, 0, 2918, 142, 1, 0, 0, 0, 2919, 2920, 7, 22, 0, 0, 2920, 2921, + 7, 8, 0, 0, 2921, 2922, 7, 3, 0, 0, 2922, 2923, 7, 12, 0, 0, 2923, 2924, + 7, 6, 0, 0, 2924, 144, 1, 0, 0, 0, 2925, 2926, 7, 22, 0, 0, 2926, 2927, + 7, 8, 0, 0, 2927, 2928, 7, 19, 0, 0, 2928, 2929, 7, 17, 0, 0, 2929, 2930, + 7, 25, 0, 0, 2930, 146, 1, 0, 0, 0, 2931, 2932, 7, 20, 0, 0, 2932, 2933, + 7, 3, 0, 0, 2933, 2934, 7, 24, 0, 0, 2934, 2935, 7, 15, 0, 0, 2935, 2936, + 7, 12, 0, 0, 2936, 2937, 7, 22, 0, 0, 2937, 148, 1, 0, 0, 0, 2938, 2939, + 7, 20, 0, 0, 2939, 2940, 7, 15, 0, 0, 2940, 2941, 7, 22, 0, 0, 2941, 2942, + 7, 20, 0, 0, 2942, 2943, 5, 95, 0, 0, 2943, 2944, 7, 25, 0, 0, 2944, 2945, + 7, 8, 0, 0, 2945, 2946, 7, 15, 0, 0, 2946, 2947, 7, 19, 0, 0, 2947, 2948, + 7, 8, 0, 0, 2948, 2949, 7, 15, 0, 0, 2949, 2950, 7, 6, 0, 0, 2950, 2951, + 7, 10, 0, 0, 2951, 150, 1, 0, 0, 0, 2952, 2953, 7, 20, 0, 0, 2953, 2954, + 7, 15, 0, 0, 2954, 2955, 7, 11, 0, 0, 2955, 2956, 7, 6, 0, 0, 2956, 2957, + 7, 19, 0, 0, 2957, 2958, 7, 22, 0, 0, 2958, 2959, 7, 8, 0, 0, 2959, 2960, + 7, 3, 0, 0, 2960, 2961, 7, 23, 0, 0, 2961, 152, 1, 0, 0, 0, 2962, 2963, + 7, 15, 0, 0, 2963, 2964, 7, 18, 0, 0, 2964, 154, 1, 0, 0, 0, 2965, 2966, + 7, 15, 0, 0, 2966, 2967, 7, 22, 0, 0, 2967, 2968, 7, 12, 0, 0, 2968, 2969, + 7, 19, 0, 0, 2969, 2970, 7, 8, 0, 0, 2970, 2971, 7, 7, 0, 0, 2971, 156, + 1, 0, 0, 0, 2972, 2973, 7, 15, 0, 0, 2973, 2974, 7, 22, 0, 0, 2974, 2975, + 7, 12, 0, 0, 2975, 2976, 7, 19, 0, 0, 2976, 2977, 7, 8, 0, 0, 2977, 2978, + 7, 7, 0, 0, 2978, 2979, 7, 4, 0, 0, 2979, 158, 1, 0, 0, 0, 2980, 2981, + 7, 15, 0, 0, 2981, 2982, 7, 12, 0, 0, 2982, 160, 1, 0, 0, 0, 2983, 2984, + 7, 15, 0, 0, 2984, 2985, 7, 12, 0, 0, 2985, 2986, 7, 4, 0, 0, 2986, 2987, + 7, 7, 0, 0, 2987, 2988, 7, 26, 0, 0, 2988, 162, 1, 0, 0, 0, 2989, 2990, + 7, 15, 0, 0, 2990, 2991, 7, 12, 0, 0, 2991, 2992, 7, 18, 0, 0, 2992, 2993, + 7, 15, 0, 0, 2993, 2994, 7, 5, 0, 0, 2994, 2995, 7, 7, 0, 0, 2995, 164, + 1, 0, 0, 0, 2996, 2997, 7, 15, 0, 0, 2997, 2998, 7, 12, 0, 0, 2998, 2999, + 7, 12, 0, 0, 2999, 3000, 7, 7, 0, 0, 3000, 3001, 7, 8, 0, 0, 3001, 166, + 1, 0, 0, 0, 3002, 3003, 7, 15, 0, 0, 3003, 3004, 7, 12, 0, 0, 3004, 3005, + 7, 19, 0, 0, 3005, 3006, 7, 17, 0, 0, 3006, 3007, 7, 6, 0, 0, 3007, 168, + 1, 0, 0, 0, 3008, 3009, 7, 15, 0, 0, 3009, 3010, 7, 12, 0, 0, 3010, 3011, + 7, 11, 0, 0, 3011, 3012, 7, 7, 0, 0, 3012, 3013, 7, 8, 0, 0, 3013, 3014, + 7, 6, 0, 0, 3014, 170, 1, 0, 0, 0, 3015, 3016, 7, 15, 0, 0, 3016, 3017, + 7, 12, 0, 0, 3017, 3018, 7, 6, 0, 0, 3018, 3019, 7, 7, 0, 0, 3019, 3020, + 7, 8, 0, 0, 3020, 3021, 7, 24, 0, 0, 3021, 3022, 7, 3, 0, 0, 3022, 3023, + 7, 5, 0, 0, 3023, 172, 1, 0, 0, 0, 3024, 3025, 7, 15, 0, 0, 3025, 3026, + 7, 12, 0, 0, 3026, 3027, 7, 6, 0, 0, 3027, 3028, 7, 19, 0, 0, 3028, 174, + 1, 0, 0, 0, 3029, 3030, 7, 15, 0, 0, 3030, 3031, 7, 11, 0, 0, 3031, 176, + 1, 0, 0, 0, 3032, 3033, 7, 15, 0, 0, 3033, 3034, 7, 6, 0, 0, 3034, 3035, + 7, 7, 0, 0, 3035, 3036, 7, 8, 0, 0, 3036, 3037, 7, 3, 0, 0, 3037, 3038, + 7, 6, 0, 0, 3038, 3039, 7, 7, 0, 0, 3039, 178, 1, 0, 0, 0, 3040, 3041, + 7, 27, 0, 0, 3041, 3042, 7, 19, 0, 0, 3042, 3043, 7, 15, 0, 0, 3043, 3044, + 7, 12, 0, 0, 3044, 180, 1, 0, 0, 0, 3045, 3046, 7, 21, 0, 0, 3046, 3047, + 7, 7, 0, 0, 3047, 3048, 7, 10, 0, 0, 3048, 182, 1, 0, 0, 0, 3049, 3050, + 7, 21, 0, 0, 3050, 3051, 7, 7, 0, 0, 3051, 3052, 7, 10, 0, 0, 3052, 3053, + 7, 11, 0, 0, 3053, 184, 1, 0, 0, 0, 3054, 3055, 7, 21, 0, 0, 3055, 3056, + 7, 15, 0, 0, 3056, 3057, 7, 5, 0, 0, 3057, 3058, 7, 5, 0, 0, 3058, 186, + 1, 0, 0, 0, 3059, 3060, 7, 5, 0, 0, 3060, 3061, 7, 3, 0, 0, 3061, 3062, + 7, 6, 0, 0, 3062, 3063, 7, 7, 0, 0, 3063, 3064, 7, 8, 0, 0, 3064, 3065, + 7, 3, 0, 0, 3065, 3066, 7, 5, 0, 0, 3066, 188, 1, 0, 0, 0, 3067, 3068, + 7, 5, 0, 0, 3068, 3069, 7, 7, 0, 0, 3069, 3070, 7, 3, 0, 0, 3070, 3071, + 7, 4, 0, 0, 3071, 3072, 7, 15, 0, 0, 3072, 3073, 7, 12, 0, 0, 3073, 3074, + 7, 22, 0, 0, 3074, 190, 1, 0, 0, 0, 3075, 3076, 7, 5, 0, 0, 3076, 3077, + 7, 7, 0, 0, 3077, 3078, 7, 3, 0, 0, 3078, 3079, 7, 24, 0, 0, 3079, 3080, + 7, 7, 0, 0, 3080, 192, 1, 0, 0, 0, 3081, 3082, 7, 5, 0, 0, 3082, 3083, + 7, 7, 0, 0, 3083, 3084, 7, 18, 0, 0, 3084, 3085, 7, 6, 0, 0, 3085, 194, + 1, 0, 0, 0, 3086, 3087, 7, 5, 0, 0, 3087, 3088, 7, 15, 0, 0, 3088, 3089, + 7, 21, 0, 0, 3089, 3090, 7, 7, 0, 0, 3090, 196, 1, 0, 0, 0, 3091, 3092, + 7, 5, 0, 0, 3092, 3093, 7, 15, 0, 0, 3093, 3094, 7, 23, 0, 0, 3094, 3095, + 7, 15, 0, 0, 3095, 3096, 7, 6, 0, 0, 3096, 198, 1, 0, 0, 0, 3097, 3098, + 7, 5, 0, 0, 3098, 3099, 7, 15, 0, 0, 3099, 3100, 7, 12, 0, 0, 3100, 3101, + 7, 7, 0, 0, 3101, 3102, 7, 3, 0, 0, 3102, 3103, 7, 8, 0, 0, 3103, 200, + 1, 0, 0, 0, 3104, 3105, 7, 5, 0, 0, 3105, 3106, 7, 15, 0, 0, 3106, 3107, + 7, 12, 0, 0, 3107, 3108, 7, 7, 0, 0, 3108, 3109, 7, 11, 0, 0, 3109, 202, + 1, 0, 0, 0, 3110, 3111, 7, 5, 0, 0, 3111, 3112, 7, 19, 0, 0, 3112, 3113, + 7, 3, 0, 0, 3113, 3114, 7, 4, 0, 0, 3114, 204, 1, 0, 0, 0, 3115, 3116, + 7, 5, 0, 0, 3116, 3117, 7, 19, 0, 0, 3117, 3118, 7, 14, 0, 0, 3118, 3119, + 7, 21, 0, 0, 3119, 206, 1, 0, 0, 0, 3120, 3121, 7, 5, 0, 0, 3121, 3122, + 7, 19, 0, 0, 3122, 3123, 7, 14, 0, 0, 3123, 3124, 7, 21, 0, 0, 3124, 3125, + 7, 7, 0, 0, 3125, 3126, 7, 4, 0, 0, 3126, 208, 1, 0, 0, 0, 3127, 3128, + 7, 5, 0, 0, 3128, 3129, 7, 19, 0, 0, 3129, 3130, 7, 19, 0, 0, 3130, 3131, + 7, 25, 0, 0, 3131, 210, 1, 0, 0, 0, 3132, 3133, 7, 5, 0, 0, 3133, 3134, + 7, 19, 0, 0, 3134, 3135, 7, 9, 0, 0, 3135, 3136, 5, 95, 0, 0, 3136, 3137, + 7, 25, 0, 0, 3137, 3138, 7, 8, 0, 0, 3138, 3139, 7, 15, 0, 0, 3139, 3140, + 7, 19, 0, 0, 3140, 3141, 7, 8, 0, 0, 3141, 3142, 7, 15, 0, 0, 3142, 3143, + 7, 6, 0, 0, 3143, 3144, 7, 10, 0, 0, 3144, 212, 1, 0, 0, 0, 3145, 3146, + 7, 23, 0, 0, 3146, 3147, 7, 3, 0, 0, 3147, 3148, 7, 11, 0, 0, 3148, 3149, + 7, 6, 0, 0, 3149, 3150, 7, 7, 0, 0, 3150, 3151, 7, 8, 0, 0, 3151, 3152, + 5, 95, 0, 0, 3152, 3153, 7, 16, 0, 0, 3153, 3154, 7, 15, 0, 0, 3154, 3155, + 7, 12, 0, 0, 3155, 3156, 7, 4, 0, 0, 3156, 214, 1, 0, 0, 0, 3157, 3158, + 7, 23, 0, 0, 3158, 3159, 7, 3, 0, 0, 3159, 3160, 7, 11, 0, 0, 3160, 3161, + 7, 6, 0, 0, 3161, 3162, 7, 7, 0, 0, 3162, 3163, 7, 8, 0, 0, 3163, 3164, + 5, 95, 0, 0, 3164, 3165, 7, 11, 0, 0, 3165, 3166, 7, 11, 0, 0, 3166, 3167, + 7, 5, 0, 0, 3167, 3168, 5, 95, 0, 0, 3168, 3169, 7, 24, 0, 0, 3169, 3170, + 7, 7, 0, 0, 3170, 3171, 7, 8, 0, 0, 3171, 3172, 7, 15, 0, 0, 3172, 3173, + 7, 18, 0, 0, 3173, 3174, 7, 10, 0, 0, 3174, 3175, 5, 95, 0, 0, 3175, 3176, + 7, 11, 0, 0, 3176, 3177, 7, 7, 0, 0, 3177, 3178, 7, 8, 0, 0, 3178, 3179, + 7, 24, 0, 0, 3179, 3180, 7, 7, 0, 0, 3180, 3181, 7, 8, 0, 0, 3181, 3182, + 5, 95, 0, 0, 3182, 3183, 7, 14, 0, 0, 3183, 3184, 7, 7, 0, 0, 3184, 3185, + 7, 8, 0, 0, 3185, 3186, 7, 6, 0, 0, 3186, 216, 1, 0, 0, 0, 3187, 3188, + 7, 23, 0, 0, 3188, 3189, 7, 3, 0, 0, 3189, 3190, 7, 6, 0, 0, 3190, 3191, + 7, 14, 0, 0, 3191, 3192, 7, 20, 0, 0, 3192, 218, 1, 0, 0, 0, 3193, 3194, + 7, 23, 0, 0, 3194, 3195, 7, 3, 0, 0, 3195, 3196, 7, 26, 0, 0, 3196, 3197, + 7, 24, 0, 0, 3197, 3198, 7, 3, 0, 0, 3198, 3199, 7, 5, 0, 0, 3199, 3200, + 7, 17, 0, 0, 3200, 3201, 7, 7, 0, 0, 3201, 220, 1, 0, 0, 0, 3202, 3203, + 7, 23, 0, 0, 3203, 3204, 7, 15, 0, 0, 3204, 3205, 7, 12, 0, 0, 3205, 3206, + 7, 24, 0, 0, 3206, 3207, 7, 3, 0, 0, 3207, 3208, 7, 5, 0, 0, 3208, 3209, + 7, 17, 0, 0, 3209, 3210, 7, 7, 0, 0, 3210, 222, 1, 0, 0, 0, 3211, 3212, + 7, 23, 0, 0, 3212, 3213, 7, 19, 0, 0, 3213, 3214, 7, 4, 0, 0, 3214, 3215, + 7, 15, 0, 0, 3215, 3216, 7, 18, 0, 0, 3216, 3217, 7, 15, 0, 0, 3217, 3218, + 7, 7, 0, 0, 3218, 3219, 7, 11, 0, 0, 3219, 224, 1, 0, 0, 0, 3220, 3221, + 7, 12, 0, 0, 3221, 3222, 7, 3, 0, 0, 3222, 3223, 7, 6, 0, 0, 3223, 3224, + 7, 17, 0, 0, 3224, 3225, 7, 8, 0, 0, 3225, 3226, 7, 3, 0, 0, 3226, 3227, + 7, 5, 0, 0, 3227, 226, 1, 0, 0, 0, 3228, 3229, 7, 12, 0, 0, 3229, 3230, + 7, 19, 0, 0, 3230, 3231, 7, 6, 0, 0, 3231, 228, 1, 0, 0, 0, 3232, 3233, + 7, 12, 0, 0, 3233, 3234, 7, 19, 0, 0, 3234, 3235, 5, 95, 0, 0, 3235, 3236, + 7, 9, 0, 0, 3236, 3237, 7, 8, 0, 0, 3237, 3238, 7, 15, 0, 0, 3238, 3239, + 7, 6, 0, 0, 3239, 3240, 7, 7, 0, 0, 3240, 3241, 5, 95, 0, 0, 3241, 3242, + 7, 6, 0, 0, 3242, 3243, 7, 19, 0, 0, 3243, 3244, 5, 95, 0, 0, 3244, 3245, + 7, 16, 0, 0, 3245, 3246, 7, 15, 0, 0, 3246, 3247, 7, 12, 0, 0, 3247, 3248, + 7, 5, 0, 0, 3248, 3249, 7, 19, 0, 0, 3249, 3250, 7, 22, 0, 0, 3250, 230, + 1, 0, 0, 0, 3251, 3252, 7, 12, 0, 0, 3252, 3253, 7, 17, 0, 0, 3253, 3254, + 7, 5, 0, 0, 3254, 3255, 7, 5, 0, 0, 3255, 232, 1, 0, 0, 0, 3256, 3257, + 7, 12, 0, 0, 3257, 3258, 7, 17, 0, 0, 3258, 3259, 7, 23, 0, 0, 3259, 3260, + 7, 16, 0, 0, 3260, 3261, 7, 7, 0, 0, 3261, 3262, 7, 8, 0, 0, 3262, 234, + 1, 0, 0, 0, 3263, 3264, 7, 19, 0, 0, 3264, 3265, 7, 12, 0, 0, 3265, 236, + 1, 0, 0, 0, 3266, 3267, 7, 19, 0, 0, 3267, 3268, 7, 25, 0, 0, 3268, 3269, + 7, 6, 0, 0, 3269, 3270, 7, 15, 0, 0, 3270, 3271, 7, 23, 0, 0, 3271, 3272, + 7, 15, 0, 0, 3272, 3273, 7, 13, 0, 0, 3273, 3274, 7, 7, 0, 0, 3274, 238, + 1, 0, 0, 0, 3275, 3276, 7, 19, 0, 0, 3276, 3277, 7, 25, 0, 0, 3277, 3278, + 7, 6, 0, 0, 3278, 3279, 7, 15, 0, 0, 3279, 3280, 7, 19, 0, 0, 3280, 3281, + 7, 12, 0, 0, 3281, 240, 1, 0, 0, 0, 3282, 3283, 7, 19, 0, 0, 3283, 3284, + 7, 25, 0, 0, 3284, 3285, 7, 6, 0, 0, 3285, 3286, 7, 15, 0, 0, 3286, 3287, + 7, 19, 0, 0, 3287, 3288, 7, 12, 0, 0, 3288, 3289, 7, 3, 0, 0, 3289, 3290, + 7, 5, 0, 0, 3290, 242, 1, 0, 0, 0, 3291, 3292, 7, 19, 0, 0, 3292, 3293, + 7, 25, 0, 0, 3293, 3294, 7, 6, 0, 0, 3294, 3295, 7, 15, 0, 0, 3295, 3296, + 7, 19, 0, 0, 3296, 3297, 7, 12, 0, 0, 3297, 3298, 7, 3, 0, 0, 3298, 3299, + 7, 5, 0, 0, 3299, 3300, 7, 5, 0, 0, 3300, 3301, 7, 10, 0, 0, 3301, 244, + 1, 0, 0, 0, 3302, 3303, 7, 19, 0, 0, 3303, 3304, 7, 8, 0, 0, 3304, 246, + 1, 0, 0, 0, 3305, 3306, 7, 19, 0, 0, 3306, 3307, 7, 8, 0, 0, 3307, 3308, + 7, 4, 0, 0, 3308, 3309, 7, 7, 0, 0, 3309, 3310, 7, 8, 0, 0, 3310, 248, + 1, 0, 0, 0, 3311, 3312, 7, 19, 0, 0, 3312, 3313, 7, 17, 0, 0, 3313, 3314, + 7, 6, 0, 0, 3314, 250, 1, 0, 0, 0, 3315, 3316, 7, 19, 0, 0, 3316, 3317, + 7, 17, 0, 0, 3317, 3318, 7, 6, 0, 0, 3318, 3319, 7, 7, 0, 0, 3319, 3320, + 7, 8, 0, 0, 3320, 252, 1, 0, 0, 0, 3321, 3322, 7, 19, 0, 0, 3322, 3323, + 7, 17, 0, 0, 3323, 3324, 7, 6, 0, 0, 3324, 3325, 7, 18, 0, 0, 3325, 3326, + 7, 15, 0, 0, 3326, 3327, 7, 5, 0, 0, 3327, 3328, 7, 7, 0, 0, 3328, 254, + 1, 0, 0, 0, 3329, 3330, 7, 19, 0, 0, 3330, 3331, 7, 24, 0, 0, 3331, 3332, + 7, 7, 0, 0, 3332, 3333, 7, 8, 0, 0, 3333, 256, 1, 0, 0, 0, 3334, 3335, + 7, 25, 0, 0, 3335, 3336, 7, 3, 0, 0, 3336, 3337, 7, 8, 0, 0, 3337, 3338, + 7, 6, 0, 0, 3338, 3339, 7, 15, 0, 0, 3339, 3340, 7, 6, 0, 0, 3340, 3341, + 7, 15, 0, 0, 3341, 3342, 7, 19, 0, 0, 3342, 3343, 7, 12, 0, 0, 3343, 258, + 1, 0, 0, 0, 3344, 3345, 7, 25, 0, 0, 3345, 3346, 7, 8, 0, 0, 3346, 3347, + 7, 15, 0, 0, 3347, 3348, 7, 23, 0, 0, 3348, 3349, 7, 3, 0, 0, 3349, 3350, + 7, 8, 0, 0, 3350, 3351, 7, 10, 0, 0, 3351, 260, 1, 0, 0, 0, 3352, 3353, + 7, 25, 0, 0, 3353, 3354, 7, 8, 0, 0, 3354, 3355, 7, 19, 0, 0, 3355, 3356, + 7, 14, 0, 0, 3356, 3357, 7, 7, 0, 0, 3357, 3358, 7, 4, 0, 0, 3358, 3359, + 7, 17, 0, 0, 3359, 3360, 7, 8, 0, 0, 3360, 3361, 7, 7, 0, 0, 3361, 262, + 1, 0, 0, 0, 3362, 3363, 7, 25, 0, 0, 3363, 3364, 7, 17, 0, 0, 3364, 3365, + 7, 8, 0, 0, 3365, 3366, 7, 22, 0, 0, 3366, 3367, 7, 7, 0, 0, 3367, 264, + 1, 0, 0, 0, 3368, 3369, 7, 8, 0, 0, 3369, 3370, 7, 3, 0, 0, 3370, 3371, + 7, 12, 0, 0, 3371, 3372, 7, 22, 0, 0, 3372, 3373, 7, 7, 0, 0, 3373, 266, + 1, 0, 0, 0, 3374, 3375, 7, 8, 0, 0, 3375, 3376, 7, 7, 0, 0, 3376, 3377, + 7, 3, 0, 0, 3377, 3378, 7, 4, 0, 0, 3378, 268, 1, 0, 0, 0, 3379, 3380, + 7, 8, 0, 0, 3380, 3381, 7, 7, 0, 0, 3381, 3382, 7, 3, 0, 0, 3382, 3383, + 7, 4, 0, 0, 3383, 3384, 7, 11, 0, 0, 3384, 270, 1, 0, 0, 0, 3385, 3386, + 7, 8, 0, 0, 3386, 3387, 7, 7, 0, 0, 3387, 3388, 7, 18, 0, 0, 3388, 3389, + 7, 7, 0, 0, 3389, 3390, 7, 8, 0, 0, 3390, 3391, 7, 7, 0, 0, 3391, 3392, + 7, 12, 0, 0, 3392, 3393, 7, 14, 0, 0, 3393, 3394, 7, 7, 0, 0, 3394, 3395, + 7, 11, 0, 0, 3395, 272, 1, 0, 0, 0, 3396, 3397, 7, 8, 0, 0, 3397, 3398, + 7, 7, 0, 0, 3398, 3399, 7, 22, 0, 0, 3399, 3400, 7, 7, 0, 0, 3400, 3401, + 7, 26, 0, 0, 3401, 3402, 7, 25, 0, 0, 3402, 274, 1, 0, 0, 0, 3403, 3404, + 7, 8, 0, 0, 3404, 3405, 7, 7, 0, 0, 3405, 3406, 7, 5, 0, 0, 3406, 3407, + 7, 7, 0, 0, 3407, 3408, 7, 3, 0, 0, 3408, 3409, 7, 11, 0, 0, 3409, 3410, + 7, 7, 0, 0, 3410, 276, 1, 0, 0, 0, 3411, 3412, 7, 8, 0, 0, 3412, 3413, + 7, 7, 0, 0, 3413, 3414, 7, 12, 0, 0, 3414, 3415, 7, 3, 0, 0, 3415, 3416, + 7, 23, 0, 0, 3416, 3417, 7, 7, 0, 0, 3417, 278, 1, 0, 0, 0, 3418, 3419, + 7, 8, 0, 0, 3419, 3420, 7, 7, 0, 0, 3420, 3421, 7, 25, 0, 0, 3421, 3422, + 7, 7, 0, 0, 3422, 3423, 7, 3, 0, 0, 3423, 3424, 7, 6, 0, 0, 3424, 280, + 1, 0, 0, 0, 3425, 3426, 7, 8, 0, 0, 3426, 3427, 7, 7, 0, 0, 3427, 3428, + 7, 25, 0, 0, 3428, 3429, 7, 5, 0, 0, 3429, 3430, 7, 3, 0, 0, 3430, 3431, + 7, 14, 0, 0, 3431, 3432, 7, 7, 0, 0, 3432, 282, 1, 0, 0, 0, 3433, 3434, + 7, 8, 0, 0, 3434, 3435, 7, 7, 0, 0, 3435, 3436, 7, 28, 0, 0, 3436, 3437, + 7, 17, 0, 0, 3437, 3438, 7, 15, 0, 0, 3438, 3439, 7, 8, 0, 0, 3439, 3440, + 7, 7, 0, 0, 3440, 284, 1, 0, 0, 0, 3441, 3442, 7, 8, 0, 0, 3442, 3443, + 7, 7, 0, 0, 3443, 3444, 7, 11, 0, 0, 3444, 3445, 7, 15, 0, 0, 3445, 3446, + 7, 22, 0, 0, 3446, 3447, 7, 12, 0, 0, 3447, 3448, 7, 3, 0, 0, 3448, 3449, + 7, 5, 0, 0, 3449, 286, 1, 0, 0, 0, 3450, 3451, 7, 8, 0, 0, 3451, 3452, + 7, 7, 0, 0, 3452, 3453, 7, 11, 0, 0, 3453, 3454, 7, 6, 0, 0, 3454, 3455, + 7, 8, 0, 0, 3455, 3456, 7, 15, 0, 0, 3456, 3457, 7, 14, 0, 0, 3457, 3458, + 7, 6, 0, 0, 3458, 288, 1, 0, 0, 0, 3459, 3460, 7, 8, 0, 0, 3460, 3461, + 7, 7, 0, 0, 3461, 3462, 7, 6, 0, 0, 3462, 3463, 7, 3, 0, 0, 3463, 3464, + 7, 15, 0, 0, 3464, 3465, 7, 12, 0, 0, 3465, 290, 1, 0, 0, 0, 3466, 3467, + 7, 8, 0, 0, 3467, 3468, 7, 7, 0, 0, 3468, 3469, 7, 6, 0, 0, 3469, 3470, + 7, 17, 0, 0, 3470, 3471, 7, 8, 0, 0, 3471, 3472, 7, 12, 0, 0, 3472, 292, + 1, 0, 0, 0, 3473, 3474, 7, 8, 0, 0, 3474, 3475, 7, 7, 0, 0, 3475, 3476, + 7, 24, 0, 0, 3476, 3477, 7, 19, 0, 0, 3477, 3478, 7, 21, 0, 0, 3478, 3479, + 7, 7, 0, 0, 3479, 294, 1, 0, 0, 0, 3480, 3481, 7, 8, 0, 0, 3481, 3482, + 7, 15, 0, 0, 3482, 3483, 7, 22, 0, 0, 3483, 3484, 7, 20, 0, 0, 3484, 3485, + 7, 6, 0, 0, 3485, 296, 1, 0, 0, 0, 3486, 3487, 7, 8, 0, 0, 3487, 3488, + 7, 5, 0, 0, 3488, 3489, 7, 15, 0, 0, 3489, 3490, 7, 21, 0, 0, 3490, 3491, + 7, 7, 0, 0, 3491, 298, 1, 0, 0, 0, 3492, 3493, 7, 11, 0, 0, 3493, 3494, + 7, 14, 0, 0, 3494, 3495, 7, 20, 0, 0, 3495, 3496, 7, 7, 0, 0, 3496, 3497, + 7, 23, 0, 0, 3497, 3498, 7, 3, 0, 0, 3498, 300, 1, 0, 0, 0, 3499, 3500, + 7, 11, 0, 0, 3500, 3501, 7, 14, 0, 0, 3501, 3502, 7, 20, 0, 0, 3502, 3503, + 7, 7, 0, 0, 3503, 3504, 7, 23, 0, 0, 3504, 3505, 7, 3, 0, 0, 3505, 3506, + 7, 11, 0, 0, 3506, 302, 1, 0, 0, 0, 3507, 3508, 7, 11, 0, 0, 3508, 3509, + 7, 7, 0, 0, 3509, 3510, 7, 5, 0, 0, 3510, 3511, 7, 7, 0, 0, 3511, 3512, + 7, 14, 0, 0, 3512, 3513, 7, 6, 0, 0, 3513, 304, 1, 0, 0, 0, 3514, 3515, + 7, 11, 0, 0, 3515, 3516, 7, 7, 0, 0, 3516, 3517, 7, 6, 0, 0, 3517, 306, + 1, 0, 0, 0, 3518, 3519, 7, 11, 0, 0, 3519, 3520, 7, 7, 0, 0, 3520, 3521, + 7, 25, 0, 0, 3521, 3522, 7, 3, 0, 0, 3522, 3523, 7, 8, 0, 0, 3523, 3524, + 7, 3, 0, 0, 3524, 3525, 7, 6, 0, 0, 3525, 3526, 7, 19, 0, 0, 3526, 3527, + 7, 8, 0, 0, 3527, 308, 1, 0, 0, 0, 3528, 3529, 7, 11, 0, 0, 3529, 3530, + 7, 20, 0, 0, 3530, 3531, 7, 19, 0, 0, 3531, 3532, 7, 9, 0, 0, 3532, 310, + 1, 0, 0, 0, 3533, 3534, 7, 11, 0, 0, 3534, 3535, 7, 15, 0, 0, 3535, 3536, + 7, 22, 0, 0, 3536, 3537, 7, 12, 0, 0, 3537, 3538, 7, 3, 0, 0, 3538, 3539, + 7, 5, 0, 0, 3539, 312, 1, 0, 0, 0, 3540, 3541, 7, 11, 0, 0, 3541, 3542, + 7, 21, 0, 0, 3542, 3543, 7, 15, 0, 0, 3543, 3544, 7, 25, 0, 0, 3544, 314, + 1, 0, 0, 0, 3545, 3546, 7, 11, 0, 0, 3546, 3547, 7, 21, 0, 0, 3547, 3548, + 7, 15, 0, 0, 3548, 3549, 7, 25, 0, 0, 3549, 3550, 5, 95, 0, 0, 3550, 3551, + 7, 28, 0, 0, 3551, 3552, 7, 17, 0, 0, 3552, 3553, 7, 7, 0, 0, 3553, 3554, + 7, 8, 0, 0, 3554, 3555, 7, 10, 0, 0, 3555, 3556, 5, 95, 0, 0, 3556, 3557, + 7, 8, 0, 0, 3557, 3558, 7, 7, 0, 0, 3558, 3559, 7, 9, 0, 0, 3559, 3560, + 7, 8, 0, 0, 3560, 3561, 7, 15, 0, 0, 3561, 3562, 7, 6, 0, 0, 3562, 3563, + 7, 7, 0, 0, 3563, 316, 1, 0, 0, 0, 3564, 3565, 7, 11, 0, 0, 3565, 3566, + 7, 25, 0, 0, 3566, 3567, 7, 3, 0, 0, 3567, 3568, 7, 6, 0, 0, 3568, 3569, + 7, 15, 0, 0, 3569, 3570, 7, 3, 0, 0, 3570, 3571, 7, 5, 0, 0, 3571, 318, + 1, 0, 0, 0, 3572, 3573, 7, 11, 0, 0, 3573, 3574, 7, 28, 0, 0, 3574, 3575, + 7, 5, 0, 0, 3575, 320, 1, 0, 0, 0, 3576, 3577, 7, 11, 0, 0, 3577, 3578, + 7, 28, 0, 0, 3578, 3579, 7, 5, 0, 0, 3579, 3580, 7, 7, 0, 0, 3580, 3581, + 7, 26, 0, 0, 3581, 3582, 7, 14, 0, 0, 3582, 3583, 7, 7, 0, 0, 3583, 3584, + 7, 25, 0, 0, 3584, 3585, 7, 6, 0, 0, 3585, 3586, 7, 15, 0, 0, 3586, 3587, + 7, 19, 0, 0, 3587, 3588, 7, 12, 0, 0, 3588, 322, 1, 0, 0, 0, 3589, 3590, + 7, 11, 0, 0, 3590, 3591, 7, 28, 0, 0, 3591, 3592, 7, 5, 0, 0, 3592, 3593, + 7, 11, 0, 0, 3593, 3594, 7, 6, 0, 0, 3594, 3595, 7, 3, 0, 0, 3595, 3596, + 7, 6, 0, 0, 3596, 3597, 7, 7, 0, 0, 3597, 324, 1, 0, 0, 0, 3598, 3599, + 7, 11, 0, 0, 3599, 3600, 7, 28, 0, 0, 3600, 3601, 7, 5, 0, 0, 3601, 3602, + 7, 9, 0, 0, 3602, 3603, 7, 3, 0, 0, 3603, 3604, 7, 8, 0, 0, 3604, 3605, + 7, 12, 0, 0, 3605, 3606, 7, 15, 0, 0, 3606, 3607, 7, 12, 0, 0, 3607, 3608, + 7, 22, 0, 0, 3608, 326, 1, 0, 0, 0, 3609, 3610, 7, 11, 0, 0, 3610, 3611, + 7, 28, 0, 0, 3611, 3612, 7, 5, 0, 0, 3612, 3613, 5, 95, 0, 0, 3613, 3614, + 7, 16, 0, 0, 3614, 3615, 7, 15, 0, 0, 3615, 3616, 7, 22, 0, 0, 3616, 3617, + 5, 95, 0, 0, 3617, 3618, 7, 8, 0, 0, 3618, 3619, 7, 7, 0, 0, 3619, 3620, + 7, 11, 0, 0, 3620, 3621, 7, 17, 0, 0, 3621, 3622, 7, 5, 0, 0, 3622, 3623, + 7, 6, 0, 0, 3623, 328, 1, 0, 0, 0, 3624, 3625, 7, 11, 0, 0, 3625, 3626, + 7, 28, 0, 0, 3626, 3627, 7, 5, 0, 0, 3627, 3628, 5, 95, 0, 0, 3628, 3629, + 7, 14, 0, 0, 3629, 3630, 7, 3, 0, 0, 3630, 3631, 7, 5, 0, 0, 3631, 3632, + 7, 14, 0, 0, 3632, 3633, 5, 95, 0, 0, 3633, 3634, 7, 18, 0, 0, 3634, 3635, + 7, 19, 0, 0, 3635, 3636, 7, 17, 0, 0, 3636, 3637, 7, 12, 0, 0, 3637, 3638, + 7, 4, 0, 0, 3638, 3639, 5, 95, 0, 0, 3639, 3640, 7, 8, 0, 0, 3640, 3641, + 7, 19, 0, 0, 3641, 3642, 7, 9, 0, 0, 3642, 3643, 7, 11, 0, 0, 3643, 330, + 1, 0, 0, 0, 3644, 3645, 7, 11, 0, 0, 3645, 3646, 7, 28, 0, 0, 3646, 3647, + 7, 5, 0, 0, 3647, 3648, 5, 95, 0, 0, 3648, 3649, 7, 11, 0, 0, 3649, 3650, + 7, 23, 0, 0, 3650, 3651, 7, 3, 0, 0, 3651, 3652, 7, 5, 0, 0, 3652, 3653, + 7, 5, 0, 0, 3653, 3654, 5, 95, 0, 0, 3654, 3655, 7, 8, 0, 0, 3655, 3656, + 7, 7, 0, 0, 3656, 3657, 7, 11, 0, 0, 3657, 3658, 7, 17, 0, 0, 3658, 3659, + 7, 5, 0, 0, 3659, 3660, 7, 6, 0, 0, 3660, 332, 1, 0, 0, 0, 3661, 3662, + 7, 11, 0, 0, 3662, 3663, 7, 11, 0, 0, 3663, 3664, 7, 5, 0, 0, 3664, 334, + 1, 0, 0, 0, 3665, 3666, 7, 11, 0, 0, 3666, 3667, 7, 6, 0, 0, 3667, 3668, + 7, 3, 0, 0, 3668, 3669, 7, 14, 0, 0, 3669, 3670, 7, 21, 0, 0, 3670, 3671, + 7, 7, 0, 0, 3671, 3672, 7, 4, 0, 0, 3672, 336, 1, 0, 0, 0, 3673, 3674, + 7, 11, 0, 0, 3674, 3675, 7, 6, 0, 0, 3675, 3676, 7, 3, 0, 0, 3676, 3677, + 7, 8, 0, 0, 3677, 3678, 7, 6, 0, 0, 3678, 3679, 7, 15, 0, 0, 3679, 3680, + 7, 12, 0, 0, 3680, 3681, 7, 22, 0, 0, 3681, 338, 1, 0, 0, 0, 3682, 3683, + 7, 11, 0, 0, 3683, 3684, 7, 6, 0, 0, 3684, 3685, 7, 3, 0, 0, 3685, 3686, + 7, 6, 0, 0, 3686, 3687, 7, 7, 0, 0, 3687, 3688, 7, 23, 0, 0, 3688, 3689, + 7, 7, 0, 0, 3689, 3690, 7, 12, 0, 0, 3690, 3691, 7, 6, 0, 0, 3691, 340, + 1, 0, 0, 0, 3692, 3693, 7, 11, 0, 0, 3693, 3694, 7, 6, 0, 0, 3694, 3695, + 7, 8, 0, 0, 3695, 3696, 7, 3, 0, 0, 3696, 3697, 7, 15, 0, 0, 3697, 3698, + 7, 22, 0, 0, 3698, 3699, 7, 20, 0, 0, 3699, 3700, 7, 6, 0, 0, 3700, 3701, + 5, 95, 0, 0, 3701, 3702, 7, 27, 0, 0, 3702, 3703, 7, 19, 0, 0, 3703, 3704, + 7, 15, 0, 0, 3704, 3705, 7, 12, 0, 0, 3705, 342, 1, 0, 0, 0, 3706, 3707, + 7, 6, 0, 0, 3707, 3708, 7, 3, 0, 0, 3708, 3709, 7, 16, 0, 0, 3709, 3710, + 7, 5, 0, 0, 3710, 3711, 7, 7, 0, 0, 3711, 344, 1, 0, 0, 0, 3712, 3713, + 7, 6, 0, 0, 3713, 3714, 7, 7, 0, 0, 3714, 3715, 7, 8, 0, 0, 3715, 3716, + 7, 23, 0, 0, 3716, 3717, 7, 15, 0, 0, 3717, 3718, 7, 12, 0, 0, 3718, 3719, + 7, 3, 0, 0, 3719, 3720, 7, 6, 0, 0, 3720, 3721, 7, 7, 0, 0, 3721, 3722, + 7, 4, 0, 0, 3722, 346, 1, 0, 0, 0, 3723, 3724, 7, 6, 0, 0, 3724, 3725, + 7, 20, 0, 0, 3725, 3726, 7, 7, 0, 0, 3726, 3727, 7, 12, 0, 0, 3727, 348, + 1, 0, 0, 0, 3728, 3729, 7, 6, 0, 0, 3729, 3730, 7, 19, 0, 0, 3730, 350, + 1, 0, 0, 0, 3731, 3732, 7, 6, 0, 0, 3732, 3733, 7, 8, 0, 0, 3733, 3734, + 7, 3, 0, 0, 3734, 3735, 7, 15, 0, 0, 3735, 3736, 7, 5, 0, 0, 3736, 3737, + 7, 15, 0, 0, 3737, 3738, 7, 12, 0, 0, 3738, 3739, 7, 22, 0, 0, 3739, 352, + 1, 0, 0, 0, 3740, 3741, 7, 6, 0, 0, 3741, 3742, 7, 8, 0, 0, 3742, 3743, + 7, 15, 0, 0, 3743, 3744, 7, 22, 0, 0, 3744, 3745, 7, 22, 0, 0, 3745, 3746, + 7, 7, 0, 0, 3746, 3747, 7, 8, 0, 0, 3747, 354, 1, 0, 0, 0, 3748, 3749, + 7, 6, 0, 0, 3749, 3750, 7, 8, 0, 0, 3750, 3751, 7, 17, 0, 0, 3751, 3752, + 7, 7, 0, 0, 3752, 356, 1, 0, 0, 0, 3753, 3754, 7, 17, 0, 0, 3754, 3755, + 7, 12, 0, 0, 3755, 3756, 7, 4, 0, 0, 3756, 3757, 7, 19, 0, 0, 3757, 358, + 1, 0, 0, 0, 3758, 3759, 7, 17, 0, 0, 3759, 3760, 7, 12, 0, 0, 3760, 3761, + 7, 15, 0, 0, 3761, 3762, 7, 19, 0, 0, 3762, 3763, 7, 12, 0, 0, 3763, 360, + 1, 0, 0, 0, 3764, 3765, 7, 17, 0, 0, 3765, 3766, 7, 12, 0, 0, 3766, 3767, + 7, 15, 0, 0, 3767, 3768, 7, 28, 0, 0, 3768, 3769, 7, 17, 0, 0, 3769, 3770, + 7, 7, 0, 0, 3770, 362, 1, 0, 0, 0, 3771, 3772, 7, 17, 0, 0, 3772, 3773, + 7, 12, 0, 0, 3773, 3774, 7, 5, 0, 0, 3774, 3775, 7, 19, 0, 0, 3775, 3776, + 7, 14, 0, 0, 3776, 3777, 7, 21, 0, 0, 3777, 364, 1, 0, 0, 0, 3778, 3779, + 7, 17, 0, 0, 3779, 3780, 7, 12, 0, 0, 3780, 3781, 7, 11, 0, 0, 3781, 3782, + 7, 15, 0, 0, 3782, 3783, 7, 22, 0, 0, 3783, 3784, 7, 12, 0, 0, 3784, 3785, + 7, 7, 0, 0, 3785, 3786, 7, 4, 0, 0, 3786, 366, 1, 0, 0, 0, 3787, 3788, + 7, 17, 0, 0, 3788, 3789, 7, 25, 0, 0, 3789, 3790, 7, 4, 0, 0, 3790, 3791, + 7, 3, 0, 0, 3791, 3792, 7, 6, 0, 0, 3792, 3793, 7, 7, 0, 0, 3793, 368, + 1, 0, 0, 0, 3794, 3795, 7, 17, 0, 0, 3795, 3796, 7, 11, 0, 0, 3796, 3797, + 7, 3, 0, 0, 3797, 3798, 7, 22, 0, 0, 3798, 3799, 7, 7, 0, 0, 3799, 370, + 1, 0, 0, 0, 3800, 3801, 7, 17, 0, 0, 3801, 3802, 7, 11, 0, 0, 3802, 3803, + 7, 7, 0, 0, 3803, 372, 1, 0, 0, 0, 3804, 3805, 7, 17, 0, 0, 3805, 3806, + 7, 11, 0, 0, 3806, 3807, 7, 15, 0, 0, 3807, 3808, 7, 12, 0, 0, 3808, 3809, + 7, 22, 0, 0, 3809, 374, 1, 0, 0, 0, 3810, 3811, 7, 24, 0, 0, 3811, 3812, + 7, 3, 0, 0, 3812, 3813, 7, 5, 0, 0, 3813, 3814, 7, 17, 0, 0, 3814, 3815, + 7, 7, 0, 0, 3815, 3816, 7, 11, 0, 0, 3816, 376, 1, 0, 0, 0, 3817, 3818, + 7, 9, 0, 0, 3818, 3819, 7, 20, 0, 0, 3819, 3820, 7, 7, 0, 0, 3820, 3821, + 7, 12, 0, 0, 3821, 378, 1, 0, 0, 0, 3822, 3823, 7, 9, 0, 0, 3823, 3824, + 7, 20, 0, 0, 3824, 3825, 7, 7, 0, 0, 3825, 3826, 7, 8, 0, 0, 3826, 3827, + 7, 7, 0, 0, 3827, 380, 1, 0, 0, 0, 3828, 3829, 7, 9, 0, 0, 3829, 3830, + 7, 20, 0, 0, 3830, 3831, 7, 15, 0, 0, 3831, 3832, 7, 5, 0, 0, 3832, 3833, + 7, 7, 0, 0, 3833, 382, 1, 0, 0, 0, 3834, 3835, 7, 9, 0, 0, 3835, 3836, + 7, 15, 0, 0, 3836, 3837, 7, 6, 0, 0, 3837, 3838, 7, 20, 0, 0, 3838, 384, + 1, 0, 0, 0, 3839, 3840, 7, 9, 0, 0, 3840, 3841, 7, 8, 0, 0, 3841, 3842, + 7, 15, 0, 0, 3842, 3843, 7, 6, 0, 0, 3843, 3844, 7, 7, 0, 0, 3844, 386, + 1, 0, 0, 0, 3845, 3846, 7, 26, 0, 0, 3846, 3847, 7, 19, 0, 0, 3847, 3848, + 7, 8, 0, 0, 3848, 388, 1, 0, 0, 0, 3849, 3850, 7, 13, 0, 0, 3850, 3851, + 7, 7, 0, 0, 3851, 3852, 7, 8, 0, 0, 3852, 3853, 7, 19, 0, 0, 3853, 3854, + 7, 18, 0, 0, 3854, 3855, 7, 15, 0, 0, 3855, 3856, 7, 5, 0, 0, 3856, 3857, + 7, 5, 0, 0, 3857, 390, 1, 0, 0, 0, 3858, 3859, 7, 6, 0, 0, 3859, 3860, + 7, 15, 0, 0, 3860, 3861, 7, 12, 0, 0, 3861, 3862, 7, 10, 0, 0, 3862, 3863, + 7, 15, 0, 0, 3863, 3864, 7, 12, 0, 0, 3864, 3865, 7, 6, 0, 0, 3865, 392, + 1, 0, 0, 0, 3866, 3867, 7, 11, 0, 0, 3867, 3868, 7, 23, 0, 0, 3868, 3869, + 7, 3, 0, 0, 3869, 3870, 7, 5, 0, 0, 3870, 3871, 7, 5, 0, 0, 3871, 3872, + 7, 15, 0, 0, 3872, 3873, 7, 12, 0, 0, 3873, 3874, 7, 6, 0, 0, 3874, 394, + 1, 0, 0, 0, 3875, 3876, 7, 23, 0, 0, 3876, 3877, 7, 7, 0, 0, 3877, 3878, + 7, 4, 0, 0, 3878, 3879, 7, 15, 0, 0, 3879, 3880, 7, 17, 0, 0, 3880, 3881, + 7, 23, 0, 0, 3881, 3882, 7, 15, 0, 0, 3882, 3883, 7, 12, 0, 0, 3883, 3884, + 7, 6, 0, 0, 3884, 396, 1, 0, 0, 0, 3885, 3886, 7, 23, 0, 0, 3886, 3887, + 7, 15, 0, 0, 3887, 3888, 7, 4, 0, 0, 3888, 3889, 7, 4, 0, 0, 3889, 3890, + 7, 5, 0, 0, 3890, 3891, 7, 7, 0, 0, 3891, 3892, 7, 15, 0, 0, 3892, 3893, + 7, 12, 0, 0, 3893, 3894, 7, 6, 0, 0, 3894, 398, 1, 0, 0, 0, 3895, 3896, + 7, 15, 0, 0, 3896, 3897, 7, 12, 0, 0, 3897, 3898, 7, 6, 0, 0, 3898, 400, + 1, 0, 0, 0, 3899, 3900, 7, 15, 0, 0, 3900, 3901, 7, 12, 0, 0, 3901, 3902, + 7, 6, 0, 0, 3902, 3903, 5, 49, 0, 0, 3903, 402, 1, 0, 0, 0, 3904, 3905, + 7, 15, 0, 0, 3905, 3906, 7, 12, 0, 0, 3906, 3907, 7, 6, 0, 0, 3907, 3908, + 5, 50, 0, 0, 3908, 404, 1, 0, 0, 0, 3909, 3910, 7, 15, 0, 0, 3910, 3911, + 7, 12, 0, 0, 3911, 3912, 7, 6, 0, 0, 3912, 3913, 5, 51, 0, 0, 3913, 406, + 1, 0, 0, 0, 3914, 3915, 7, 15, 0, 0, 3915, 3916, 7, 12, 0, 0, 3916, 3917, + 7, 6, 0, 0, 3917, 3918, 5, 52, 0, 0, 3918, 408, 1, 0, 0, 0, 3919, 3920, + 7, 15, 0, 0, 3920, 3921, 7, 12, 0, 0, 3921, 3922, 7, 6, 0, 0, 3922, 3923, + 5, 56, 0, 0, 3923, 410, 1, 0, 0, 0, 3924, 3925, 7, 15, 0, 0, 3925, 3926, + 7, 12, 0, 0, 3926, 3927, 7, 6, 0, 0, 3927, 3928, 7, 7, 0, 0, 3928, 3929, + 7, 22, 0, 0, 3929, 3930, 7, 7, 0, 0, 3930, 3931, 7, 8, 0, 0, 3931, 412, + 1, 0, 0, 0, 3932, 3933, 7, 16, 0, 0, 3933, 3934, 7, 15, 0, 0, 3934, 3935, + 7, 22, 0, 0, 3935, 3936, 7, 15, 0, 0, 3936, 3937, 7, 12, 0, 0, 3937, 3938, + 7, 6, 0, 0, 3938, 414, 1, 0, 0, 0, 3939, 3940, 7, 8, 0, 0, 3940, 3941, + 7, 7, 0, 0, 3941, 3942, 7, 3, 0, 0, 3942, 3943, 7, 5, 0, 0, 3943, 416, + 1, 0, 0, 0, 3944, 3945, 7, 4, 0, 0, 3945, 3946, 7, 19, 0, 0, 3946, 3947, + 7, 17, 0, 0, 3947, 3948, 7, 16, 0, 0, 3948, 3949, 7, 5, 0, 0, 3949, 3950, + 7, 7, 0, 0, 3950, 418, 1, 0, 0, 0, 3951, 3952, 7, 25, 0, 0, 3952, 3953, + 7, 8, 0, 0, 3953, 3954, 7, 7, 0, 0, 3954, 3955, 7, 14, 0, 0, 3955, 3956, + 7, 15, 0, 0, 3956, 3957, 7, 11, 0, 0, 3957, 3958, 7, 15, 0, 0, 3958, 3959, + 7, 19, 0, 0, 3959, 3960, 7, 12, 0, 0, 3960, 420, 1, 0, 0, 0, 3961, 3962, + 7, 18, 0, 0, 3962, 3963, 7, 5, 0, 0, 3963, 3964, 7, 19, 0, 0, 3964, 3965, + 7, 3, 0, 0, 3965, 3966, 7, 6, 0, 0, 3966, 422, 1, 0, 0, 0, 3967, 3968, + 7, 18, 0, 0, 3968, 3969, 7, 5, 0, 0, 3969, 3970, 7, 19, 0, 0, 3970, 3971, + 7, 3, 0, 0, 3971, 3972, 7, 6, 0, 0, 3972, 3973, 5, 52, 0, 0, 3973, 424, + 1, 0, 0, 0, 3974, 3975, 7, 18, 0, 0, 3975, 3976, 7, 5, 0, 0, 3976, 3977, + 7, 19, 0, 0, 3977, 3978, 7, 3, 0, 0, 3978, 3979, 7, 6, 0, 0, 3979, 3980, + 5, 56, 0, 0, 3980, 426, 1, 0, 0, 0, 3981, 3982, 7, 4, 0, 0, 3982, 3983, + 7, 7, 0, 0, 3983, 3984, 7, 14, 0, 0, 3984, 3985, 7, 15, 0, 0, 3985, 3986, + 7, 23, 0, 0, 3986, 3987, 7, 3, 0, 0, 3987, 3988, 7, 5, 0, 0, 3988, 428, + 1, 0, 0, 0, 3989, 3990, 7, 4, 0, 0, 3990, 3991, 7, 7, 0, 0, 3991, 3992, + 7, 14, 0, 0, 3992, 430, 1, 0, 0, 0, 3993, 3994, 7, 12, 0, 0, 3994, 3995, + 7, 17, 0, 0, 3995, 3996, 7, 23, 0, 0, 3996, 3997, 7, 7, 0, 0, 3997, 3998, + 7, 8, 0, 0, 3998, 3999, 7, 15, 0, 0, 3999, 4000, 7, 14, 0, 0, 4000, 432, + 1, 0, 0, 0, 4001, 4002, 7, 4, 0, 0, 4002, 4003, 7, 3, 0, 0, 4003, 4004, + 7, 6, 0, 0, 4004, 4005, 7, 7, 0, 0, 4005, 434, 1, 0, 0, 0, 4006, 4007, + 7, 6, 0, 0, 4007, 4008, 7, 15, 0, 0, 4008, 4009, 7, 23, 0, 0, 4009, 4010, + 7, 7, 0, 0, 4010, 436, 1, 0, 0, 0, 4011, 4012, 7, 6, 0, 0, 4012, 4013, + 7, 15, 0, 0, 4013, 4014, 7, 23, 0, 0, 4014, 4015, 7, 7, 0, 0, 4015, 4016, + 7, 11, 0, 0, 4016, 4017, 7, 6, 0, 0, 4017, 4018, 7, 3, 0, 0, 4018, 4019, + 7, 23, 0, 0, 4019, 4020, 7, 25, 0, 0, 4020, 438, 1, 0, 0, 0, 4021, 4022, + 7, 4, 0, 0, 4022, 4023, 7, 3, 0, 0, 4023, 4024, 7, 6, 0, 0, 4024, 4025, + 7, 7, 0, 0, 4025, 4026, 7, 6, 0, 0, 4026, 4027, 7, 15, 0, 0, 4027, 4028, + 7, 23, 0, 0, 4028, 4029, 7, 7, 0, 0, 4029, 440, 1, 0, 0, 0, 4030, 4031, + 7, 10, 0, 0, 4031, 4032, 7, 7, 0, 0, 4032, 4033, 7, 3, 0, 0, 4033, 4034, + 7, 8, 0, 0, 4034, 442, 1, 0, 0, 0, 4035, 4036, 7, 14, 0, 0, 4036, 4037, + 7, 20, 0, 0, 4037, 4038, 7, 3, 0, 0, 4038, 4039, 7, 8, 0, 0, 4039, 444, + 1, 0, 0, 0, 4040, 4041, 7, 24, 0, 0, 4041, 4042, 7, 3, 0, 0, 4042, 4043, + 7, 8, 0, 0, 4043, 4044, 7, 14, 0, 0, 4044, 4045, 7, 20, 0, 0, 4045, 4046, + 7, 3, 0, 0, 4046, 4047, 7, 8, 0, 0, 4047, 446, 1, 0, 0, 0, 4048, 4049, + 7, 12, 0, 0, 4049, 4050, 7, 24, 0, 0, 4050, 4051, 7, 3, 0, 0, 4051, 4052, + 7, 8, 0, 0, 4052, 4053, 7, 14, 0, 0, 4053, 4054, 7, 20, 0, 0, 4054, 4055, + 7, 3, 0, 0, 4055, 4056, 7, 8, 0, 0, 4056, 448, 1, 0, 0, 0, 4057, 4058, + 7, 12, 0, 0, 4058, 4059, 7, 3, 0, 0, 4059, 4060, 7, 6, 0, 0, 4060, 4061, + 7, 15, 0, 0, 4061, 4062, 7, 19, 0, 0, 4062, 4063, 7, 12, 0, 0, 4063, 4064, + 7, 3, 0, 0, 4064, 4065, 7, 5, 0, 0, 4065, 450, 1, 0, 0, 0, 4066, 4067, + 7, 16, 0, 0, 4067, 4068, 7, 15, 0, 0, 4068, 4069, 7, 12, 0, 0, 4069, 4070, + 7, 3, 0, 0, 4070, 4071, 7, 8, 0, 0, 4071, 4072, 7, 10, 0, 0, 4072, 452, + 1, 0, 0, 0, 4073, 4074, 7, 24, 0, 0, 4074, 4075, 7, 3, 0, 0, 4075, 4076, + 7, 8, 0, 0, 4076, 4077, 7, 16, 0, 0, 4077, 4078, 7, 15, 0, 0, 4078, 4079, + 7, 12, 0, 0, 4079, 4080, 7, 3, 0, 0, 4080, 4081, 7, 8, 0, 0, 4081, 4082, + 7, 10, 0, 0, 4082, 454, 1, 0, 0, 0, 4083, 4084, 7, 6, 0, 0, 4084, 4085, + 7, 15, 0, 0, 4085, 4086, 7, 12, 0, 0, 4086, 4087, 7, 10, 0, 0, 4087, 4088, + 7, 16, 0, 0, 4088, 4089, 7, 5, 0, 0, 4089, 4090, 7, 19, 0, 0, 4090, 4091, + 7, 16, 0, 0, 4091, 456, 1, 0, 0, 0, 4092, 4093, 7, 16, 0, 0, 4093, 4094, + 7, 5, 0, 0, 4094, 4095, 7, 19, 0, 0, 4095, 4096, 7, 16, 0, 0, 4096, 458, + 1, 0, 0, 0, 4097, 4098, 7, 23, 0, 0, 4098, 4099, 7, 7, 0, 0, 4099, 4100, + 7, 4, 0, 0, 4100, 4101, 7, 15, 0, 0, 4101, 4102, 7, 17, 0, 0, 4102, 4103, + 7, 23, 0, 0, 4103, 4104, 7, 16, 0, 0, 4104, 4105, 7, 5, 0, 0, 4105, 4106, + 7, 19, 0, 0, 4106, 4107, 7, 16, 0, 0, 4107, 460, 1, 0, 0, 0, 4108, 4109, + 7, 5, 0, 0, 4109, 4110, 7, 19, 0, 0, 4110, 4111, 7, 12, 0, 0, 4111, 4112, + 7, 22, 0, 0, 4112, 462, 1, 0, 0, 0, 4113, 4114, 7, 5, 0, 0, 4114, 4115, + 7, 19, 0, 0, 4115, 4116, 7, 12, 0, 0, 4116, 4117, 7, 22, 0, 0, 4117, 4118, + 7, 16, 0, 0, 4118, 4119, 7, 5, 0, 0, 4119, 4120, 7, 19, 0, 0, 4120, 4121, + 7, 16, 0, 0, 4121, 464, 1, 0, 0, 0, 4122, 4123, 7, 6, 0, 0, 4123, 4124, + 7, 15, 0, 0, 4124, 4125, 7, 12, 0, 0, 4125, 4126, 7, 10, 0, 0, 4126, 4127, + 7, 6, 0, 0, 4127, 4128, 7, 7, 0, 0, 4128, 4129, 7, 26, 0, 0, 4129, 4130, + 7, 6, 0, 0, 4130, 466, 1, 0, 0, 0, 4131, 4132, 7, 6, 0, 0, 4132, 4133, + 7, 7, 0, 0, 4133, 4134, 7, 26, 0, 0, 4134, 4135, 7, 6, 0, 0, 4135, 468, + 1, 0, 0, 0, 4136, 4137, 7, 23, 0, 0, 4137, 4138, 7, 7, 0, 0, 4138, 4139, + 7, 4, 0, 0, 4139, 4140, 7, 15, 0, 0, 4140, 4141, 7, 17, 0, 0, 4141, 4142, + 7, 23, 0, 0, 4142, 4143, 7, 6, 0, 0, 4143, 4144, 7, 7, 0, 0, 4144, 4145, + 7, 26, 0, 0, 4145, 4146, 7, 6, 0, 0, 4146, 470, 1, 0, 0, 0, 4147, 4148, + 7, 5, 0, 0, 4148, 4149, 7, 19, 0, 0, 4149, 4150, 7, 12, 0, 0, 4150, 4151, + 7, 22, 0, 0, 4151, 4152, 7, 6, 0, 0, 4152, 4153, 7, 7, 0, 0, 4153, 4154, + 7, 26, 0, 0, 4154, 4155, 7, 6, 0, 0, 4155, 472, 1, 0, 0, 0, 4156, 4157, + 7, 7, 0, 0, 4157, 4158, 7, 12, 0, 0, 4158, 4159, 7, 17, 0, 0, 4159, 4160, + 7, 23, 0, 0, 4160, 474, 1, 0, 0, 0, 4161, 4162, 7, 24, 0, 0, 4162, 4163, + 7, 3, 0, 0, 4163, 4164, 7, 8, 0, 0, 4164, 4165, 7, 10, 0, 0, 4165, 4166, + 7, 15, 0, 0, 4166, 4167, 7, 12, 0, 0, 4167, 4168, 7, 22, 0, 0, 4168, 476, + 1, 0, 0, 0, 4169, 4170, 7, 11, 0, 0, 4170, 4171, 7, 7, 0, 0, 4171, 4172, + 7, 8, 0, 0, 4172, 4173, 7, 15, 0, 0, 4173, 4174, 7, 3, 0, 0, 4174, 4175, + 7, 5, 0, 0, 4175, 478, 1, 0, 0, 0, 4176, 4177, 7, 24, 0, 0, 4177, 4178, + 7, 7, 0, 0, 4178, 4179, 7, 14, 0, 0, 4179, 4180, 7, 6, 0, 0, 4180, 4181, + 7, 19, 0, 0, 4181, 4182, 7, 8, 0, 0, 4182, 480, 1, 0, 0, 0, 4183, 4184, + 7, 10, 0, 0, 4184, 4185, 7, 7, 0, 0, 4185, 4186, 7, 3, 0, 0, 4186, 4187, + 7, 8, 0, 0, 4187, 4188, 5, 95, 0, 0, 4188, 4189, 7, 23, 0, 0, 4189, 4190, + 7, 19, 0, 0, 4190, 4191, 7, 12, 0, 0, 4191, 4192, 7, 6, 0, 0, 4192, 4193, + 7, 20, 0, 0, 4193, 482, 1, 0, 0, 0, 4194, 4195, 7, 4, 0, 0, 4195, 4196, + 7, 3, 0, 0, 4196, 4197, 7, 10, 0, 0, 4197, 4198, 5, 95, 0, 0, 4198, 4199, + 7, 20, 0, 0, 4199, 4200, 7, 19, 0, 0, 4200, 4201, 7, 17, 0, 0, 4201, 4202, + 7, 8, 0, 0, 4202, 484, 1, 0, 0, 0, 4203, 4204, 7, 4, 0, 0, 4204, 4205, + 7, 3, 0, 0, 4205, 4206, 7, 10, 0, 0, 4206, 4207, 5, 95, 0, 0, 4207, 4208, + 7, 23, 0, 0, 4208, 4209, 7, 15, 0, 0, 4209, 4210, 7, 12, 0, 0, 4210, 4211, + 7, 17, 0, 0, 4211, 4212, 7, 6, 0, 0, 4212, 4213, 7, 7, 0, 0, 4213, 486, + 1, 0, 0, 0, 4214, 4215, 7, 4, 0, 0, 4215, 4216, 7, 3, 0, 0, 4216, 4217, + 7, 10, 0, 0, 4217, 4218, 5, 95, 0, 0, 4218, 4219, 7, 11, 0, 0, 4219, 4220, + 7, 7, 0, 0, 4220, 4221, 7, 14, 0, 0, 4221, 4222, 7, 19, 0, 0, 4222, 4223, + 7, 12, 0, 0, 4223, 4224, 7, 4, 0, 0, 4224, 488, 1, 0, 0, 0, 4225, 4226, + 7, 20, 0, 0, 4226, 4227, 7, 19, 0, 0, 4227, 4228, 7, 17, 0, 0, 4228, 4229, + 7, 8, 0, 0, 4229, 4230, 5, 95, 0, 0, 4230, 4231, 7, 23, 0, 0, 4231, 4232, + 7, 15, 0, 0, 4232, 4233, 7, 12, 0, 0, 4233, 4234, 7, 17, 0, 0, 4234, 4235, + 7, 6, 0, 0, 4235, 4236, 7, 7, 0, 0, 4236, 490, 1, 0, 0, 0, 4237, 4238, + 7, 20, 0, 0, 4238, 4239, 7, 19, 0, 0, 4239, 4240, 7, 17, 0, 0, 4240, 4241, + 7, 8, 0, 0, 4241, 4242, 5, 95, 0, 0, 4242, 4243, 7, 11, 0, 0, 4243, 4244, + 7, 7, 0, 0, 4244, 4245, 7, 14, 0, 0, 4245, 4246, 7, 19, 0, 0, 4246, 4247, + 7, 12, 0, 0, 4247, 4248, 7, 4, 0, 0, 4248, 492, 1, 0, 0, 0, 4249, 4250, + 7, 23, 0, 0, 4250, 4251, 7, 15, 0, 0, 4251, 4252, 7, 12, 0, 0, 4252, 4253, + 7, 17, 0, 0, 4253, 4254, 7, 6, 0, 0, 4254, 4255, 7, 7, 0, 0, 4255, 4256, + 5, 95, 0, 0, 4256, 4257, 7, 11, 0, 0, 4257, 4258, 7, 7, 0, 0, 4258, 4259, + 7, 14, 0, 0, 4259, 4260, 7, 19, 0, 0, 4260, 4261, 7, 12, 0, 0, 4261, 4262, + 7, 4, 0, 0, 4262, 494, 1, 0, 0, 0, 4263, 4264, 7, 11, 0, 0, 4264, 4265, + 7, 7, 0, 0, 4265, 4266, 7, 14, 0, 0, 4266, 4267, 7, 19, 0, 0, 4267, 4268, + 7, 12, 0, 0, 4268, 4269, 7, 4, 0, 0, 4269, 4270, 5, 95, 0, 0, 4270, 4271, + 7, 23, 0, 0, 4271, 4272, 7, 15, 0, 0, 4272, 4273, 7, 14, 0, 0, 4273, 4274, + 7, 8, 0, 0, 4274, 4275, 7, 19, 0, 0, 4275, 4276, 7, 11, 0, 0, 4276, 4277, + 7, 7, 0, 0, 4277, 4278, 7, 14, 0, 0, 4278, 4279, 7, 19, 0, 0, 4279, 4280, + 7, 12, 0, 0, 4280, 4281, 7, 4, 0, 0, 4281, 496, 1, 0, 0, 0, 4282, 4283, + 7, 23, 0, 0, 4283, 4284, 7, 15, 0, 0, 4284, 4285, 7, 12, 0, 0, 4285, 4286, + 7, 17, 0, 0, 4286, 4287, 7, 6, 0, 0, 4287, 4288, 7, 7, 0, 0, 4288, 4289, + 5, 95, 0, 0, 4289, 4290, 7, 23, 0, 0, 4290, 4291, 7, 15, 0, 0, 4291, 4292, + 7, 14, 0, 0, 4292, 4293, 7, 8, 0, 0, 4293, 4294, 7, 19, 0, 0, 4294, 4295, + 7, 11, 0, 0, 4295, 4296, 7, 7, 0, 0, 4296, 4297, 7, 14, 0, 0, 4297, 4298, + 7, 19, 0, 0, 4298, 4299, 7, 12, 0, 0, 4299, 4300, 7, 4, 0, 0, 4300, 498, + 1, 0, 0, 0, 4301, 4302, 7, 20, 0, 0, 4302, 4303, 7, 19, 0, 0, 4303, 4304, + 7, 17, 0, 0, 4304, 4305, 7, 8, 0, 0, 4305, 4306, 5, 95, 0, 0, 4306, 4307, + 7, 23, 0, 0, 4307, 4308, 7, 15, 0, 0, 4308, 4309, 7, 14, 0, 0, 4309, 4310, + 7, 8, 0, 0, 4310, 4311, 7, 19, 0, 0, 4311, 4312, 7, 11, 0, 0, 4312, 4313, + 7, 7, 0, 0, 4313, 4314, 7, 14, 0, 0, 4314, 4315, 7, 19, 0, 0, 4315, 4316, + 7, 12, 0, 0, 4316, 4317, 7, 4, 0, 0, 4317, 500, 1, 0, 0, 0, 4318, 4319, + 7, 4, 0, 0, 4319, 4320, 7, 3, 0, 0, 4320, 4321, 7, 10, 0, 0, 4321, 4322, + 5, 95, 0, 0, 4322, 4323, 7, 23, 0, 0, 4323, 4324, 7, 15, 0, 0, 4324, 4325, + 7, 14, 0, 0, 4325, 4326, 7, 8, 0, 0, 4326, 4327, 7, 19, 0, 0, 4327, 4328, + 7, 11, 0, 0, 4328, 4329, 7, 7, 0, 0, 4329, 4330, 7, 14, 0, 0, 4330, 4331, + 7, 19, 0, 0, 4331, 4332, 7, 12, 0, 0, 4332, 4333, 7, 4, 0, 0, 4333, 502, + 1, 0, 0, 0, 4334, 4335, 7, 27, 0, 0, 4335, 4336, 7, 11, 0, 0, 4336, 4337, + 7, 19, 0, 0, 4337, 4338, 7, 12, 0, 0, 4338, 4339, 5, 95, 0, 0, 4339, 4340, + 7, 3, 0, 0, 4340, 4341, 7, 8, 0, 0, 4341, 4342, 7, 8, 0, 0, 4342, 4343, + 7, 3, 0, 0, 4343, 4344, 7, 10, 0, 0, 4344, 504, 1, 0, 0, 0, 4345, 4346, + 7, 27, 0, 0, 4346, 4347, 7, 11, 0, 0, 4347, 4348, 7, 19, 0, 0, 4348, 4349, + 7, 12, 0, 0, 4349, 4350, 5, 95, 0, 0, 4350, 4351, 7, 3, 0, 0, 4351, 4352, + 7, 8, 0, 0, 4352, 4353, 7, 8, 0, 0, 4353, 4354, 7, 3, 0, 0, 4354, 4355, + 7, 10, 0, 0, 4355, 4356, 7, 3, 0, 0, 4356, 4357, 7, 22, 0, 0, 4357, 4358, + 7, 22, 0, 0, 4358, 506, 1, 0, 0, 0, 4359, 4360, 7, 27, 0, 0, 4360, 4361, + 7, 11, 0, 0, 4361, 4362, 7, 19, 0, 0, 4362, 4363, 7, 12, 0, 0, 4363, 4364, + 5, 95, 0, 0, 4364, 4365, 7, 3, 0, 0, 4365, 4366, 7, 8, 0, 0, 4366, 4367, + 7, 8, 0, 0, 4367, 4368, 7, 3, 0, 0, 4368, 4369, 7, 10, 0, 0, 4369, 4370, + 5, 95, 0, 0, 4370, 4371, 7, 3, 0, 0, 4371, 4372, 7, 25, 0, 0, 4372, 4373, + 7, 25, 0, 0, 4373, 4374, 7, 7, 0, 0, 4374, 4375, 7, 12, 0, 0, 4375, 4376, + 7, 4, 0, 0, 4376, 508, 1, 0, 0, 0, 4377, 4378, 7, 27, 0, 0, 4378, 4379, + 7, 11, 0, 0, 4379, 4380, 7, 19, 0, 0, 4380, 4381, 7, 12, 0, 0, 4381, 4382, + 5, 95, 0, 0, 4382, 4383, 7, 3, 0, 0, 4383, 4384, 7, 8, 0, 0, 4384, 4385, + 7, 8, 0, 0, 4385, 4386, 7, 3, 0, 0, 4386, 4387, 7, 10, 0, 0, 4387, 4388, + 5, 95, 0, 0, 4388, 4389, 7, 15, 0, 0, 4389, 4390, 7, 12, 0, 0, 4390, 4391, + 7, 11, 0, 0, 4391, 4392, 7, 7, 0, 0, 4392, 4393, 7, 8, 0, 0, 4393, 4394, + 7, 6, 0, 0, 4394, 510, 1, 0, 0, 0, 4395, 4396, 7, 27, 0, 0, 4396, 4397, + 7, 11, 0, 0, 4397, 4398, 7, 19, 0, 0, 4398, 4399, 7, 12, 0, 0, 4399, 4400, + 5, 95, 0, 0, 4400, 4401, 7, 14, 0, 0, 4401, 4402, 7, 19, 0, 0, 4402, 4403, + 7, 12, 0, 0, 4403, 4404, 7, 6, 0, 0, 4404, 4405, 7, 3, 0, 0, 4405, 4406, + 7, 15, 0, 0, 4406, 4407, 7, 12, 0, 0, 4407, 4408, 7, 11, 0, 0, 4408, 512, + 1, 0, 0, 0, 4409, 4410, 7, 27, 0, 0, 4410, 4411, 7, 11, 0, 0, 4411, 4412, + 7, 19, 0, 0, 4412, 4413, 7, 12, 0, 0, 4413, 4414, 5, 95, 0, 0, 4414, 4415, + 7, 14, 0, 0, 4415, 4416, 7, 19, 0, 0, 4416, 4417, 7, 12, 0, 0, 4417, 4418, + 7, 6, 0, 0, 4418, 4419, 7, 3, 0, 0, 4419, 4420, 7, 15, 0, 0, 4420, 4421, + 7, 12, 0, 0, 4421, 4422, 7, 11, 0, 0, 4422, 4423, 5, 95, 0, 0, 4423, 4424, + 7, 25, 0, 0, 4424, 4425, 7, 3, 0, 0, 4425, 4426, 7, 6, 0, 0, 4426, 4427, + 7, 20, 0, 0, 4427, 514, 1, 0, 0, 0, 4428, 4429, 7, 27, 0, 0, 4429, 4430, + 7, 11, 0, 0, 4430, 4431, 7, 19, 0, 0, 4431, 4432, 7, 12, 0, 0, 4432, 4433, + 5, 95, 0, 0, 4433, 4434, 7, 4, 0, 0, 4434, 4435, 7, 7, 0, 0, 4435, 4436, + 7, 25, 0, 0, 4436, 4437, 7, 6, 0, 0, 4437, 4438, 7, 20, 0, 0, 4438, 516, + 1, 0, 0, 0, 4439, 4440, 7, 27, 0, 0, 4440, 4441, 7, 11, 0, 0, 4441, 4442, + 7, 19, 0, 0, 4442, 4443, 7, 12, 0, 0, 4443, 4444, 5, 95, 0, 0, 4444, 4445, + 7, 7, 0, 0, 4445, 4446, 7, 26, 0, 0, 4446, 4447, 7, 6, 0, 0, 4447, 4448, + 7, 8, 0, 0, 4448, 4449, 7, 3, 0, 0, 4449, 4450, 7, 14, 0, 0, 4450, 4451, + 7, 6, 0, 0, 4451, 518, 1, 0, 0, 0, 4452, 4453, 7, 27, 0, 0, 4453, 4454, + 7, 11, 0, 0, 4454, 4455, 7, 19, 0, 0, 4455, 4456, 7, 12, 0, 0, 4456, 4457, + 5, 95, 0, 0, 4457, 4458, 7, 15, 0, 0, 4458, 4459, 7, 12, 0, 0, 4459, 4460, + 7, 11, 0, 0, 4460, 4461, 7, 7, 0, 0, 4461, 4462, 7, 8, 0, 0, 4462, 4463, + 7, 6, 0, 0, 4463, 520, 1, 0, 0, 0, 4464, 4465, 7, 27, 0, 0, 4465, 4466, + 7, 11, 0, 0, 4466, 4467, 7, 19, 0, 0, 4467, 4468, 7, 12, 0, 0, 4468, 4469, + 5, 95, 0, 0, 4469, 4470, 7, 21, 0, 0, 4470, 4471, 7, 7, 0, 0, 4471, 4472, + 7, 10, 0, 0, 4472, 4473, 7, 11, 0, 0, 4473, 522, 1, 0, 0, 0, 4474, 4475, + 7, 27, 0, 0, 4475, 4476, 7, 11, 0, 0, 4476, 4477, 7, 19, 0, 0, 4477, 4478, + 7, 12, 0, 0, 4478, 4479, 5, 95, 0, 0, 4479, 4480, 7, 5, 0, 0, 4480, 4481, + 7, 7, 0, 0, 4481, 4482, 7, 12, 0, 0, 4482, 4483, 7, 22, 0, 0, 4483, 4484, + 7, 6, 0, 0, 4484, 4485, 7, 20, 0, 0, 4485, 524, 1, 0, 0, 0, 4486, 4487, + 7, 27, 0, 0, 4487, 4488, 7, 11, 0, 0, 4488, 4489, 7, 19, 0, 0, 4489, 4490, + 7, 12, 0, 0, 4490, 4491, 5, 95, 0, 0, 4491, 4492, 7, 23, 0, 0, 4492, 4493, + 7, 7, 0, 0, 4493, 4494, 7, 8, 0, 0, 4494, 4495, 7, 22, 0, 0, 4495, 4496, + 7, 7, 0, 0, 4496, 526, 1, 0, 0, 0, 4497, 4498, 7, 27, 0, 0, 4498, 4499, + 7, 11, 0, 0, 4499, 4500, 7, 19, 0, 0, 4500, 4501, 7, 12, 0, 0, 4501, 4502, + 5, 95, 0, 0, 4502, 4503, 7, 23, 0, 0, 4503, 4504, 7, 7, 0, 0, 4504, 4505, + 7, 8, 0, 0, 4505, 4506, 7, 22, 0, 0, 4506, 4507, 7, 7, 0, 0, 4507, 4508, + 5, 95, 0, 0, 4508, 4509, 7, 25, 0, 0, 4509, 4510, 7, 3, 0, 0, 4510, 4511, + 7, 6, 0, 0, 4511, 4512, 7, 14, 0, 0, 4512, 4513, 7, 20, 0, 0, 4513, 528, + 1, 0, 0, 0, 4514, 4515, 7, 27, 0, 0, 4515, 4516, 7, 11, 0, 0, 4516, 4517, + 7, 19, 0, 0, 4517, 4518, 7, 12, 0, 0, 4518, 4519, 5, 95, 0, 0, 4519, 4520, + 7, 23, 0, 0, 4520, 4521, 7, 7, 0, 0, 4521, 4522, 7, 8, 0, 0, 4522, 4523, + 7, 22, 0, 0, 4523, 4524, 7, 7, 0, 0, 4524, 4525, 5, 95, 0, 0, 4525, 4526, + 7, 25, 0, 0, 4526, 4527, 7, 8, 0, 0, 4527, 4528, 7, 7, 0, 0, 4528, 4529, + 7, 11, 0, 0, 4529, 4530, 7, 7, 0, 0, 4530, 4531, 7, 8, 0, 0, 4531, 4532, + 7, 24, 0, 0, 4532, 4533, 7, 7, 0, 0, 4533, 530, 1, 0, 0, 0, 4534, 4535, + 7, 27, 0, 0, 4535, 4536, 7, 11, 0, 0, 4536, 4537, 7, 19, 0, 0, 4537, 4538, + 7, 12, 0, 0, 4538, 4539, 5, 95, 0, 0, 4539, 4540, 7, 19, 0, 0, 4540, 4541, + 7, 16, 0, 0, 4541, 4542, 7, 27, 0, 0, 4542, 4543, 7, 7, 0, 0, 4543, 4544, + 7, 14, 0, 0, 4544, 4545, 7, 6, 0, 0, 4545, 532, 1, 0, 0, 0, 4546, 4547, + 7, 27, 0, 0, 4547, 4548, 7, 11, 0, 0, 4548, 4549, 7, 19, 0, 0, 4549, 4550, + 7, 12, 0, 0, 4550, 4551, 5, 95, 0, 0, 4551, 4552, 7, 19, 0, 0, 4552, 4553, + 7, 16, 0, 0, 4553, 4554, 7, 27, 0, 0, 4554, 4555, 7, 7, 0, 0, 4555, 4556, + 7, 14, 0, 0, 4556, 4557, 7, 6, 0, 0, 4557, 4558, 7, 3, 0, 0, 4558, 4559, + 7, 22, 0, 0, 4559, 4560, 7, 22, 0, 0, 4560, 534, 1, 0, 0, 0, 4561, 4562, + 7, 27, 0, 0, 4562, 4563, 7, 11, 0, 0, 4563, 4564, 7, 19, 0, 0, 4564, 4565, + 7, 12, 0, 0, 4565, 4566, 5, 95, 0, 0, 4566, 4567, 7, 19, 0, 0, 4567, 4568, + 7, 24, 0, 0, 4568, 4569, 7, 7, 0, 0, 4569, 4570, 7, 8, 0, 0, 4570, 4571, + 7, 5, 0, 0, 4571, 4572, 7, 3, 0, 0, 4572, 4573, 7, 25, 0, 0, 4573, 4574, + 7, 11, 0, 0, 4574, 536, 1, 0, 0, 0, 4575, 4576, 7, 27, 0, 0, 4576, 4577, + 7, 11, 0, 0, 4577, 4578, 7, 19, 0, 0, 4578, 4579, 7, 12, 0, 0, 4579, 4580, + 5, 95, 0, 0, 4580, 4581, 7, 25, 0, 0, 4581, 4582, 7, 8, 0, 0, 4582, 4583, + 7, 7, 0, 0, 4583, 4584, 7, 6, 0, 0, 4584, 4585, 7, 6, 0, 0, 4585, 4586, + 7, 10, 0, 0, 4586, 538, 1, 0, 0, 0, 4587, 4588, 7, 27, 0, 0, 4588, 4589, + 7, 11, 0, 0, 4589, 4590, 7, 19, 0, 0, 4590, 4591, 7, 12, 0, 0, 4591, 4592, + 5, 95, 0, 0, 4592, 4593, 7, 28, 0, 0, 4593, 4594, 7, 17, 0, 0, 4594, 4595, + 7, 19, 0, 0, 4595, 4596, 7, 6, 0, 0, 4596, 4597, 7, 7, 0, 0, 4597, 540, + 1, 0, 0, 0, 4598, 4599, 7, 27, 0, 0, 4599, 4600, 7, 11, 0, 0, 4600, 4601, + 7, 19, 0, 0, 4601, 4602, 7, 12, 0, 0, 4602, 4603, 5, 95, 0, 0, 4603, 4604, + 7, 8, 0, 0, 4604, 4605, 7, 7, 0, 0, 4605, 4606, 7, 23, 0, 0, 4606, 4607, + 7, 19, 0, 0, 4607, 4608, 7, 24, 0, 0, 4608, 4609, 7, 7, 0, 0, 4609, 542, + 1, 0, 0, 0, 4610, 4611, 7, 27, 0, 0, 4611, 4612, 7, 11, 0, 0, 4612, 4613, + 7, 19, 0, 0, 4613, 4614, 7, 12, 0, 0, 4614, 4615, 5, 95, 0, 0, 4615, 4616, + 7, 8, 0, 0, 4616, 4617, 7, 7, 0, 0, 4617, 4618, 7, 25, 0, 0, 4618, 4619, + 7, 5, 0, 0, 4619, 4620, 7, 3, 0, 0, 4620, 4621, 7, 14, 0, 0, 4621, 4622, + 7, 7, 0, 0, 4622, 544, 1, 0, 0, 0, 4623, 4624, 7, 27, 0, 0, 4624, 4625, + 7, 11, 0, 0, 4625, 4626, 7, 19, 0, 0, 4626, 4627, 7, 12, 0, 0, 4627, 4628, + 5, 95, 0, 0, 4628, 4629, 7, 11, 0, 0, 4629, 4630, 7, 14, 0, 0, 4630, 4631, + 7, 20, 0, 0, 4631, 4632, 7, 7, 0, 0, 4632, 4633, 7, 23, 0, 0, 4633, 4634, + 7, 3, 0, 0, 4634, 4635, 5, 95, 0, 0, 4635, 4636, 7, 24, 0, 0, 4636, 4637, + 7, 3, 0, 0, 4637, 4638, 7, 5, 0, 0, 4638, 4639, 7, 15, 0, 0, 4639, 4640, + 7, 4, 0, 0, 4640, 546, 1, 0, 0, 0, 4641, 4642, 7, 27, 0, 0, 4642, 4643, + 7, 11, 0, 0, 4643, 4644, 7, 19, 0, 0, 4644, 4645, 7, 12, 0, 0, 4645, 4646, + 5, 95, 0, 0, 4646, 4647, 7, 11, 0, 0, 4647, 4648, 7, 14, 0, 0, 4648, 4649, + 7, 20, 0, 0, 4649, 4650, 7, 7, 0, 0, 4650, 4651, 7, 23, 0, 0, 4651, 4652, + 7, 3, 0, 0, 4652, 4653, 5, 95, 0, 0, 4653, 4654, 7, 24, 0, 0, 4654, 4655, + 7, 3, 0, 0, 4655, 4656, 7, 5, 0, 0, 4656, 4657, 7, 15, 0, 0, 4657, 4658, + 7, 4, 0, 0, 4658, 4659, 7, 3, 0, 0, 4659, 4660, 7, 6, 0, 0, 4660, 4661, + 7, 15, 0, 0, 4661, 4662, 7, 19, 0, 0, 4662, 4663, 7, 12, 0, 0, 4663, 4664, + 5, 95, 0, 0, 4664, 4665, 7, 8, 0, 0, 4665, 4666, 7, 7, 0, 0, 4666, 4667, + 7, 25, 0, 0, 4667, 4668, 7, 19, 0, 0, 4668, 4669, 7, 8, 0, 0, 4669, 4670, + 7, 6, 0, 0, 4670, 548, 1, 0, 0, 0, 4671, 4672, 7, 27, 0, 0, 4672, 4673, + 7, 11, 0, 0, 4673, 4674, 7, 19, 0, 0, 4674, 4675, 7, 12, 0, 0, 4675, 4676, + 5, 95, 0, 0, 4676, 4677, 7, 11, 0, 0, 4677, 4678, 7, 7, 0, 0, 4678, 4679, + 7, 3, 0, 0, 4679, 4680, 7, 8, 0, 0, 4680, 4681, 7, 14, 0, 0, 4681, 4682, + 7, 20, 0, 0, 4682, 550, 1, 0, 0, 0, 4683, 4684, 7, 27, 0, 0, 4684, 4685, + 7, 11, 0, 0, 4685, 4686, 7, 19, 0, 0, 4686, 4687, 7, 12, 0, 0, 4687, 4688, + 5, 95, 0, 0, 4688, 4689, 7, 11, 0, 0, 4689, 4690, 7, 7, 0, 0, 4690, 4691, + 7, 6, 0, 0, 4691, 552, 1, 0, 0, 0, 4692, 4693, 7, 27, 0, 0, 4693, 4694, + 7, 11, 0, 0, 4694, 4695, 7, 19, 0, 0, 4695, 4696, 7, 12, 0, 0, 4696, 4697, + 5, 95, 0, 0, 4697, 4698, 7, 11, 0, 0, 4698, 4699, 7, 6, 0, 0, 4699, 4700, + 7, 19, 0, 0, 4700, 4701, 7, 8, 0, 0, 4701, 4702, 7, 3, 0, 0, 4702, 4703, + 7, 22, 0, 0, 4703, 4704, 7, 7, 0, 0, 4704, 4705, 5, 95, 0, 0, 4705, 4706, + 7, 18, 0, 0, 4706, 4707, 7, 8, 0, 0, 4707, 4708, 7, 7, 0, 0, 4708, 4709, + 7, 7, 0, 0, 4709, 554, 1, 0, 0, 0, 4710, 4711, 7, 27, 0, 0, 4711, 4712, + 7, 11, 0, 0, 4712, 4713, 7, 19, 0, 0, 4713, 4714, 7, 12, 0, 0, 4714, 4715, + 5, 95, 0, 0, 4715, 4716, 7, 11, 0, 0, 4716, 4717, 7, 6, 0, 0, 4717, 4718, + 7, 19, 0, 0, 4718, 4719, 7, 8, 0, 0, 4719, 4720, 7, 3, 0, 0, 4720, 4721, + 7, 22, 0, 0, 4721, 4722, 7, 7, 0, 0, 4722, 4723, 5, 95, 0, 0, 4723, 4724, + 7, 11, 0, 0, 4724, 4725, 7, 15, 0, 0, 4725, 4726, 7, 13, 0, 0, 4726, 4727, + 7, 7, 0, 0, 4727, 556, 1, 0, 0, 0, 4728, 4729, 7, 27, 0, 0, 4729, 4730, + 7, 11, 0, 0, 4730, 4731, 7, 19, 0, 0, 4731, 4732, 7, 12, 0, 0, 4732, 4733, + 5, 95, 0, 0, 4733, 4734, 7, 6, 0, 0, 4734, 4735, 7, 3, 0, 0, 4735, 4736, + 7, 16, 0, 0, 4736, 4737, 7, 5, 0, 0, 4737, 4738, 7, 7, 0, 0, 4738, 558, + 1, 0, 0, 0, 4739, 4740, 7, 27, 0, 0, 4740, 4741, 7, 11, 0, 0, 4741, 4742, + 7, 19, 0, 0, 4742, 4743, 7, 12, 0, 0, 4743, 4744, 5, 95, 0, 0, 4744, 4745, + 7, 6, 0, 0, 4745, 4746, 7, 10, 0, 0, 4746, 4747, 7, 25, 0, 0, 4747, 4748, + 7, 7, 0, 0, 4748, 560, 1, 0, 0, 0, 4749, 4750, 7, 27, 0, 0, 4750, 4751, + 7, 11, 0, 0, 4751, 4752, 7, 19, 0, 0, 4752, 4753, 7, 12, 0, 0, 4753, 4754, + 5, 95, 0, 0, 4754, 4755, 7, 17, 0, 0, 4755, 4756, 7, 12, 0, 0, 4756, 4757, + 7, 28, 0, 0, 4757, 4758, 7, 17, 0, 0, 4758, 4759, 7, 19, 0, 0, 4759, 4760, + 7, 6, 0, 0, 4760, 4761, 7, 7, 0, 0, 4761, 562, 1, 0, 0, 0, 4762, 4763, + 7, 27, 0, 0, 4763, 4764, 7, 11, 0, 0, 4764, 4765, 7, 19, 0, 0, 4765, 4766, + 7, 12, 0, 0, 4766, 4767, 5, 95, 0, 0, 4767, 4768, 7, 24, 0, 0, 4768, 4769, + 7, 3, 0, 0, 4769, 4770, 7, 5, 0, 0, 4770, 4771, 7, 15, 0, 0, 4771, 4772, + 7, 4, 0, 0, 4772, 564, 1, 0, 0, 0, 4773, 4774, 7, 27, 0, 0, 4774, 4775, + 7, 11, 0, 0, 4775, 4776, 7, 19, 0, 0, 4776, 4777, 7, 12, 0, 0, 4777, 4778, + 5, 95, 0, 0, 4778, 4779, 7, 24, 0, 0, 4779, 4780, 7, 3, 0, 0, 4780, 4781, + 7, 5, 0, 0, 4781, 4782, 7, 17, 0, 0, 4782, 4783, 7, 7, 0, 0, 4783, 566, + 1, 0, 0, 0, 4784, 4785, 7, 12, 0, 0, 4785, 4786, 7, 7, 0, 0, 4786, 4787, + 7, 11, 0, 0, 4787, 4788, 7, 6, 0, 0, 4788, 4789, 7, 7, 0, 0, 4789, 4790, + 7, 4, 0, 0, 4790, 568, 1, 0, 0, 0, 4791, 4792, 7, 19, 0, 0, 4792, 4793, + 7, 8, 0, 0, 4793, 4794, 7, 4, 0, 0, 4794, 4795, 7, 15, 0, 0, 4795, 4796, + 7, 12, 0, 0, 4796, 4797, 7, 3, 0, 0, 4797, 4798, 7, 5, 0, 0, 4798, 4799, + 7, 15, 0, 0, 4799, 4800, 7, 6, 0, 0, 4800, 4801, 7, 10, 0, 0, 4801, 570, + 1, 0, 0, 0, 4802, 4803, 7, 25, 0, 0, 4803, 4804, 7, 3, 0, 0, 4804, 4805, + 7, 6, 0, 0, 4805, 4806, 7, 20, 0, 0, 4806, 572, 1, 0, 0, 0, 4807, 4808, + 7, 3, 0, 0, 4808, 4809, 7, 24, 0, 0, 4809, 4810, 7, 22, 0, 0, 4810, 574, + 1, 0, 0, 0, 4811, 4812, 7, 16, 0, 0, 4812, 4813, 7, 15, 0, 0, 4813, 4814, + 7, 6, 0, 0, 4814, 4815, 5, 95, 0, 0, 4815, 4816, 7, 3, 0, 0, 4816, 4817, + 7, 12, 0, 0, 4817, 4818, 7, 4, 0, 0, 4818, 576, 1, 0, 0, 0, 4819, 4820, + 7, 16, 0, 0, 4820, 4821, 7, 15, 0, 0, 4821, 4822, 7, 6, 0, 0, 4822, 4823, + 5, 95, 0, 0, 4823, 4824, 7, 19, 0, 0, 4824, 4825, 7, 8, 0, 0, 4825, 578, + 1, 0, 0, 0, 4826, 4827, 7, 16, 0, 0, 4827, 4828, 7, 15, 0, 0, 4828, 4829, + 7, 6, 0, 0, 4829, 4830, 5, 95, 0, 0, 4830, 4831, 7, 26, 0, 0, 4831, 4832, + 7, 19, 0, 0, 4832, 4833, 7, 8, 0, 0, 4833, 580, 1, 0, 0, 0, 4834, 4835, + 7, 14, 0, 0, 4835, 4836, 7, 19, 0, 0, 4836, 4837, 7, 17, 0, 0, 4837, 4838, + 7, 12, 0, 0, 4838, 4839, 7, 6, 0, 0, 4839, 582, 1, 0, 0, 0, 4840, 4841, + 7, 14, 0, 0, 4841, 4842, 7, 17, 0, 0, 4842, 4843, 7, 23, 0, 0, 4843, 4844, + 7, 7, 0, 0, 4844, 4845, 5, 95, 0, 0, 4845, 4846, 7, 4, 0, 0, 4846, 4847, + 7, 15, 0, 0, 4847, 4848, 7, 11, 0, 0, 4848, 4849, 7, 6, 0, 0, 4849, 584, + 1, 0, 0, 0, 4850, 4851, 7, 4, 0, 0, 4851, 4852, 7, 7, 0, 0, 4852, 4853, + 7, 12, 0, 0, 4853, 4854, 7, 11, 0, 0, 4854, 4855, 7, 7, 0, 0, 4855, 4856, + 5, 95, 0, 0, 4856, 4857, 7, 8, 0, 0, 4857, 4858, 7, 3, 0, 0, 4858, 4859, + 7, 12, 0, 0, 4859, 4860, 7, 21, 0, 0, 4860, 586, 1, 0, 0, 0, 4861, 4862, + 7, 18, 0, 0, 4862, 4863, 7, 15, 0, 0, 4863, 4864, 7, 8, 0, 0, 4864, 4865, + 7, 11, 0, 0, 4865, 4866, 7, 6, 0, 0, 4866, 4867, 5, 95, 0, 0, 4867, 4868, + 7, 24, 0, 0, 4868, 4869, 7, 3, 0, 0, 4869, 4870, 7, 5, 0, 0, 4870, 4871, + 7, 17, 0, 0, 4871, 4872, 7, 7, 0, 0, 4872, 588, 1, 0, 0, 0, 4873, 4874, + 7, 22, 0, 0, 4874, 4875, 7, 8, 0, 0, 4875, 4876, 7, 19, 0, 0, 4876, 4877, + 7, 17, 0, 0, 4877, 4878, 7, 25, 0, 0, 4878, 4879, 5, 95, 0, 0, 4879, 4880, + 7, 14, 0, 0, 4880, 4881, 7, 19, 0, 0, 4881, 4882, 7, 12, 0, 0, 4882, 4883, + 7, 14, 0, 0, 4883, 4884, 7, 3, 0, 0, 4884, 4885, 7, 6, 0, 0, 4885, 590, + 1, 0, 0, 0, 4886, 4887, 7, 5, 0, 0, 4887, 4888, 7, 3, 0, 0, 4888, 4889, + 7, 22, 0, 0, 4889, 592, 1, 0, 0, 0, 4890, 4891, 7, 5, 0, 0, 4891, 4892, + 7, 3, 0, 0, 4892, 4893, 7, 11, 0, 0, 4893, 4894, 7, 6, 0, 0, 4894, 4895, + 5, 95, 0, 0, 4895, 4896, 7, 24, 0, 0, 4896, 4897, 7, 3, 0, 0, 4897, 4898, + 7, 5, 0, 0, 4898, 4899, 7, 17, 0, 0, 4899, 4900, 7, 7, 0, 0, 4900, 594, + 1, 0, 0, 0, 4901, 4902, 7, 5, 0, 0, 4902, 4903, 7, 7, 0, 0, 4903, 4904, + 7, 3, 0, 0, 4904, 4905, 7, 4, 0, 0, 4905, 596, 1, 0, 0, 0, 4906, 4907, + 7, 23, 0, 0, 4907, 4908, 7, 3, 0, 0, 4908, 4909, 7, 26, 0, 0, 4909, 598, + 1, 0, 0, 0, 4910, 4911, 7, 23, 0, 0, 4911, 4912, 7, 15, 0, 0, 4912, 4913, + 7, 12, 0, 0, 4913, 600, 1, 0, 0, 0, 4914, 4915, 7, 12, 0, 0, 4915, 4916, + 7, 6, 0, 0, 4916, 4917, 7, 15, 0, 0, 4917, 4918, 7, 5, 0, 0, 4918, 4919, + 7, 7, 0, 0, 4919, 602, 1, 0, 0, 0, 4920, 4921, 7, 12, 0, 0, 4921, 4922, + 7, 6, 0, 0, 4922, 4923, 7, 20, 0, 0, 4923, 4924, 5, 95, 0, 0, 4924, 4925, + 7, 24, 0, 0, 4925, 4926, 7, 3, 0, 0, 4926, 4927, 7, 5, 0, 0, 4927, 4928, + 7, 17, 0, 0, 4928, 4929, 7, 7, 0, 0, 4929, 604, 1, 0, 0, 0, 4930, 4931, + 7, 25, 0, 0, 4931, 4932, 7, 7, 0, 0, 4932, 4933, 7, 8, 0, 0, 4933, 4934, + 7, 14, 0, 0, 4934, 4935, 7, 7, 0, 0, 4935, 4936, 7, 12, 0, 0, 4936, 4937, + 7, 6, 0, 0, 4937, 4938, 5, 95, 0, 0, 4938, 4939, 7, 8, 0, 0, 4939, 4940, + 7, 3, 0, 0, 4940, 4941, 7, 12, 0, 0, 4941, 4942, 7, 21, 0, 0, 4942, 606, + 1, 0, 0, 0, 4943, 4944, 7, 8, 0, 0, 4944, 4945, 7, 3, 0, 0, 4945, 4946, + 7, 12, 0, 0, 4946, 4947, 7, 21, 0, 0, 4947, 608, 1, 0, 0, 0, 4948, 4949, + 7, 8, 0, 0, 4949, 4950, 7, 19, 0, 0, 4950, 4951, 7, 9, 0, 0, 4951, 4952, + 5, 95, 0, 0, 4952, 4953, 7, 12, 0, 0, 4953, 4954, 7, 17, 0, 0, 4954, 4955, + 7, 23, 0, 0, 4955, 4956, 7, 16, 0, 0, 4956, 4957, 7, 7, 0, 0, 4957, 4958, + 7, 8, 0, 0, 4958, 610, 1, 0, 0, 0, 4959, 4960, 7, 11, 0, 0, 4960, 4961, + 7, 6, 0, 0, 4961, 4962, 7, 4, 0, 0, 4962, 612, 1, 0, 0, 0, 4963, 4964, + 7, 11, 0, 0, 4964, 4965, 7, 6, 0, 0, 4965, 4966, 7, 4, 0, 0, 4966, 4967, + 7, 4, 0, 0, 4967, 4968, 7, 7, 0, 0, 4968, 4969, 7, 24, 0, 0, 4969, 614, + 1, 0, 0, 0, 4970, 4971, 7, 11, 0, 0, 4971, 4972, 7, 6, 0, 0, 4972, 4973, + 7, 4, 0, 0, 4973, 4974, 7, 4, 0, 0, 4974, 4975, 7, 7, 0, 0, 4975, 4976, + 7, 24, 0, 0, 4976, 4977, 5, 95, 0, 0, 4977, 4978, 7, 25, 0, 0, 4978, 4979, + 7, 19, 0, 0, 4979, 4980, 7, 25, 0, 0, 4980, 616, 1, 0, 0, 0, 4981, 4982, + 7, 11, 0, 0, 4982, 4983, 7, 6, 0, 0, 4983, 4984, 7, 4, 0, 0, 4984, 4985, + 7, 4, 0, 0, 4985, 4986, 7, 7, 0, 0, 4986, 4987, 7, 24, 0, 0, 4987, 4988, + 5, 95, 0, 0, 4988, 4989, 7, 11, 0, 0, 4989, 4990, 7, 3, 0, 0, 4990, 4991, + 7, 23, 0, 0, 4991, 4992, 7, 25, 0, 0, 4992, 618, 1, 0, 0, 0, 4993, 4994, + 7, 11, 0, 0, 4994, 4995, 7, 17, 0, 0, 4995, 4996, 7, 23, 0, 0, 4996, 620, + 1, 0, 0, 0, 4997, 4998, 7, 24, 0, 0, 4998, 4999, 7, 3, 0, 0, 4999, 5000, + 7, 8, 0, 0, 5000, 5001, 5, 95, 0, 0, 5001, 5002, 7, 25, 0, 0, 5002, 5003, + 7, 19, 0, 0, 5003, 5004, 7, 25, 0, 0, 5004, 622, 1, 0, 0, 0, 5005, 5006, + 7, 24, 0, 0, 5006, 5007, 7, 3, 0, 0, 5007, 5008, 7, 8, 0, 0, 5008, 5009, + 5, 95, 0, 0, 5009, 5010, 7, 11, 0, 0, 5010, 5011, 7, 3, 0, 0, 5011, 5012, + 7, 23, 0, 0, 5012, 5013, 7, 25, 0, 0, 5013, 624, 1, 0, 0, 0, 5014, 5015, + 7, 24, 0, 0, 5015, 5016, 7, 3, 0, 0, 5016, 5017, 7, 8, 0, 0, 5017, 5018, + 7, 15, 0, 0, 5018, 5019, 7, 3, 0, 0, 5019, 5020, 7, 12, 0, 0, 5020, 5021, + 7, 14, 0, 0, 5021, 5022, 7, 7, 0, 0, 5022, 626, 1, 0, 0, 0, 5023, 5024, + 7, 14, 0, 0, 5024, 5025, 7, 17, 0, 0, 5025, 5026, 7, 8, 0, 0, 5026, 5027, + 7, 8, 0, 0, 5027, 5028, 7, 7, 0, 0, 5028, 5029, 7, 12, 0, 0, 5029, 5030, + 7, 6, 0, 0, 5030, 5031, 5, 95, 0, 0, 5031, 5032, 7, 4, 0, 0, 5032, 5033, + 7, 3, 0, 0, 5033, 5034, 7, 6, 0, 0, 5034, 5035, 7, 7, 0, 0, 5035, 628, + 1, 0, 0, 0, 5036, 5037, 7, 14, 0, 0, 5037, 5038, 7, 17, 0, 0, 5038, 5039, + 7, 8, 0, 0, 5039, 5040, 7, 8, 0, 0, 5040, 5041, 7, 7, 0, 0, 5041, 5042, + 7, 12, 0, 0, 5042, 5043, 7, 6, 0, 0, 5043, 5044, 5, 95, 0, 0, 5044, 5045, + 7, 6, 0, 0, 5045, 5046, 7, 15, 0, 0, 5046, 5047, 7, 23, 0, 0, 5047, 5048, + 7, 7, 0, 0, 5048, 630, 1, 0, 0, 0, 5049, 5050, 7, 14, 0, 0, 5050, 5051, + 7, 17, 0, 0, 5051, 5052, 7, 8, 0, 0, 5052, 5053, 7, 8, 0, 0, 5053, 5054, + 7, 7, 0, 0, 5054, 5055, 7, 12, 0, 0, 5055, 5056, 7, 6, 0, 0, 5056, 5057, + 5, 95, 0, 0, 5057, 5058, 7, 6, 0, 0, 5058, 5059, 7, 15, 0, 0, 5059, 5060, + 7, 23, 0, 0, 5060, 5061, 7, 7, 0, 0, 5061, 5062, 7, 11, 0, 0, 5062, 5063, + 7, 6, 0, 0, 5063, 5064, 7, 3, 0, 0, 5064, 5065, 7, 23, 0, 0, 5065, 5066, + 7, 25, 0, 0, 5066, 632, 1, 0, 0, 0, 5067, 5068, 7, 5, 0, 0, 5068, 5069, + 7, 19, 0, 0, 5069, 5070, 7, 14, 0, 0, 5070, 5071, 7, 3, 0, 0, 5071, 5072, + 7, 5, 0, 0, 5072, 5073, 7, 6, 0, 0, 5073, 5074, 7, 15, 0, 0, 5074, 5075, + 7, 23, 0, 0, 5075, 5076, 7, 7, 0, 0, 5076, 634, 1, 0, 0, 0, 5077, 5078, + 7, 14, 0, 0, 5078, 5079, 7, 17, 0, 0, 5079, 5080, 7, 8, 0, 0, 5080, 5081, + 7, 4, 0, 0, 5081, 5082, 7, 3, 0, 0, 5082, 5083, 7, 6, 0, 0, 5083, 5084, + 7, 7, 0, 0, 5084, 636, 1, 0, 0, 0, 5085, 5086, 7, 14, 0, 0, 5086, 5087, + 7, 17, 0, 0, 5087, 5088, 7, 8, 0, 0, 5088, 5089, 7, 6, 0, 0, 5089, 5090, + 7, 15, 0, 0, 5090, 5091, 7, 23, 0, 0, 5091, 5092, 7, 7, 0, 0, 5092, 638, + 1, 0, 0, 0, 5093, 5094, 7, 4, 0, 0, 5094, 5095, 7, 3, 0, 0, 5095, 5096, + 7, 6, 0, 0, 5096, 5097, 7, 7, 0, 0, 5097, 5098, 5, 95, 0, 0, 5098, 5099, + 7, 3, 0, 0, 5099, 5100, 7, 4, 0, 0, 5100, 5101, 7, 4, 0, 0, 5101, 640, + 1, 0, 0, 0, 5102, 5103, 7, 4, 0, 0, 5103, 5104, 7, 3, 0, 0, 5104, 5105, + 7, 6, 0, 0, 5105, 5106, 7, 7, 0, 0, 5106, 5107, 5, 95, 0, 0, 5107, 5108, + 7, 11, 0, 0, 5108, 5109, 7, 17, 0, 0, 5109, 5110, 7, 16, 0, 0, 5110, 642, + 1, 0, 0, 0, 5111, 5112, 7, 7, 0, 0, 5112, 5113, 7, 26, 0, 0, 5113, 5114, + 7, 6, 0, 0, 5114, 5115, 7, 8, 0, 0, 5115, 5116, 7, 3, 0, 0, 5116, 5117, + 7, 14, 0, 0, 5117, 5118, 7, 6, 0, 0, 5118, 644, 1, 0, 0, 0, 5119, 5120, + 7, 5, 0, 0, 5120, 5121, 7, 19, 0, 0, 5121, 5122, 7, 14, 0, 0, 5122, 5123, + 7, 3, 0, 0, 5123, 5124, 7, 5, 0, 0, 5124, 5125, 7, 6, 0, 0, 5125, 5126, + 7, 15, 0, 0, 5126, 5127, 7, 23, 0, 0, 5127, 5128, 7, 7, 0, 0, 5128, 5129, + 7, 11, 0, 0, 5129, 5130, 7, 6, 0, 0, 5130, 5131, 7, 3, 0, 0, 5131, 5132, + 7, 23, 0, 0, 5132, 5133, 7, 25, 0, 0, 5133, 646, 1, 0, 0, 0, 5134, 5135, + 7, 12, 0, 0, 5135, 5136, 7, 19, 0, 0, 5136, 5137, 7, 9, 0, 0, 5137, 648, + 1, 0, 0, 0, 5138, 5139, 7, 25, 0, 0, 5139, 5140, 7, 19, 0, 0, 5140, 5141, + 7, 11, 0, 0, 5141, 5142, 7, 15, 0, 0, 5142, 5143, 7, 6, 0, 0, 5143, 5144, + 7, 15, 0, 0, 5144, 5145, 7, 19, 0, 0, 5145, 5146, 7, 12, 0, 0, 5146, 650, + 1, 0, 0, 0, 5147, 5148, 7, 11, 0, 0, 5148, 5149, 7, 17, 0, 0, 5149, 5150, + 7, 16, 0, 0, 5150, 5151, 7, 11, 0, 0, 5151, 5152, 7, 6, 0, 0, 5152, 5153, + 7, 8, 0, 0, 5153, 652, 1, 0, 0, 0, 5154, 5155, 7, 11, 0, 0, 5155, 5156, + 7, 17, 0, 0, 5156, 5157, 7, 16, 0, 0, 5157, 5158, 7, 11, 0, 0, 5158, 5159, + 7, 6, 0, 0, 5159, 5160, 7, 8, 0, 0, 5160, 5161, 7, 15, 0, 0, 5161, 5162, + 7, 12, 0, 0, 5162, 5163, 7, 22, 0, 0, 5163, 654, 1, 0, 0, 0, 5164, 5165, + 7, 11, 0, 0, 5165, 5166, 7, 10, 0, 0, 5166, 5167, 7, 11, 0, 0, 5167, 5168, + 7, 4, 0, 0, 5168, 5169, 7, 3, 0, 0, 5169, 5170, 7, 6, 0, 0, 5170, 5171, + 7, 7, 0, 0, 5171, 656, 1, 0, 0, 0, 5172, 5173, 7, 6, 0, 0, 5173, 5174, + 7, 8, 0, 0, 5174, 5175, 7, 15, 0, 0, 5175, 5176, 7, 23, 0, 0, 5176, 658, + 1, 0, 0, 0, 5177, 5178, 7, 17, 0, 0, 5178, 5179, 7, 6, 0, 0, 5179, 5180, + 7, 14, 0, 0, 5180, 5181, 5, 95, 0, 0, 5181, 5182, 7, 4, 0, 0, 5182, 5183, + 7, 3, 0, 0, 5183, 5184, 7, 6, 0, 0, 5184, 5185, 7, 7, 0, 0, 5185, 660, + 1, 0, 0, 0, 5186, 5187, 7, 17, 0, 0, 5187, 5188, 7, 6, 0, 0, 5188, 5189, + 7, 14, 0, 0, 5189, 5190, 5, 95, 0, 0, 5190, 5191, 7, 6, 0, 0, 5191, 5192, + 7, 15, 0, 0, 5192, 5193, 7, 23, 0, 0, 5193, 5194, 7, 7, 0, 0, 5194, 662, + 1, 0, 0, 0, 5195, 5196, 7, 17, 0, 0, 5196, 5197, 7, 6, 0, 0, 5197, 5198, + 7, 14, 0, 0, 5198, 5199, 5, 95, 0, 0, 5199, 5200, 7, 6, 0, 0, 5200, 5201, + 7, 15, 0, 0, 5201, 5202, 7, 23, 0, 0, 5202, 5203, 7, 7, 0, 0, 5203, 5204, + 7, 11, 0, 0, 5204, 5205, 7, 6, 0, 0, 5205, 5206, 7, 3, 0, 0, 5206, 5207, + 7, 23, 0, 0, 5207, 5208, 7, 25, 0, 0, 5208, 664, 1, 0, 0, 0, 5209, 5210, + 7, 3, 0, 0, 5210, 5211, 7, 14, 0, 0, 5211, 5212, 7, 14, 0, 0, 5212, 5213, + 7, 19, 0, 0, 5213, 5214, 7, 17, 0, 0, 5214, 5215, 7, 12, 0, 0, 5215, 5216, + 7, 6, 0, 0, 5216, 666, 1, 0, 0, 0, 5217, 5218, 7, 3, 0, 0, 5218, 5219, + 7, 14, 0, 0, 5219, 5220, 7, 6, 0, 0, 5220, 5221, 7, 15, 0, 0, 5221, 5222, + 7, 19, 0, 0, 5222, 5223, 7, 12, 0, 0, 5223, 668, 1, 0, 0, 0, 5224, 5225, + 7, 3, 0, 0, 5225, 5226, 7, 18, 0, 0, 5226, 5227, 7, 6, 0, 0, 5227, 5228, + 7, 7, 0, 0, 5228, 5229, 7, 8, 0, 0, 5229, 670, 1, 0, 0, 0, 5230, 5231, + 7, 3, 0, 0, 5231, 5232, 7, 22, 0, 0, 5232, 5233, 7, 22, 0, 0, 5233, 5234, + 7, 8, 0, 0, 5234, 5235, 7, 7, 0, 0, 5235, 5236, 7, 22, 0, 0, 5236, 5237, + 7, 3, 0, 0, 5237, 5238, 7, 6, 0, 0, 5238, 5239, 7, 7, 0, 0, 5239, 672, + 1, 0, 0, 0, 5240, 5241, 7, 3, 0, 0, 5241, 5242, 7, 5, 0, 0, 5242, 5243, + 7, 22, 0, 0, 5243, 5244, 7, 19, 0, 0, 5244, 5245, 7, 8, 0, 0, 5245, 5246, + 7, 15, 0, 0, 5246, 5247, 7, 6, 0, 0, 5247, 5248, 7, 20, 0, 0, 5248, 5249, + 7, 23, 0, 0, 5249, 674, 1, 0, 0, 0, 5250, 5251, 7, 3, 0, 0, 5251, 5252, + 7, 12, 0, 0, 5252, 5253, 7, 10, 0, 0, 5253, 676, 1, 0, 0, 0, 5254, 5255, + 7, 3, 0, 0, 5255, 5256, 7, 6, 0, 0, 5256, 678, 1, 0, 0, 0, 5257, 5258, + 7, 3, 0, 0, 5258, 5259, 7, 17, 0, 0, 5259, 5260, 7, 6, 0, 0, 5260, 5261, + 7, 20, 0, 0, 5261, 5262, 7, 19, 0, 0, 5262, 5263, 7, 8, 0, 0, 5263, 5264, + 7, 11, 0, 0, 5264, 680, 1, 0, 0, 0, 5265, 5266, 7, 3, 0, 0, 5266, 5267, + 7, 17, 0, 0, 5267, 5268, 7, 6, 0, 0, 5268, 5269, 7, 19, 0, 0, 5269, 5270, + 7, 14, 0, 0, 5270, 5271, 7, 19, 0, 0, 5271, 5272, 7, 23, 0, 0, 5272, 5273, + 7, 23, 0, 0, 5273, 5274, 7, 15, 0, 0, 5274, 5275, 7, 6, 0, 0, 5275, 682, + 1, 0, 0, 0, 5276, 5277, 7, 3, 0, 0, 5277, 5278, 7, 17, 0, 0, 5278, 5279, + 7, 6, 0, 0, 5279, 5280, 7, 19, 0, 0, 5280, 5281, 7, 7, 0, 0, 5281, 5282, + 7, 26, 0, 0, 5282, 5283, 7, 6, 0, 0, 5283, 5284, 7, 7, 0, 0, 5284, 5285, + 7, 12, 0, 0, 5285, 5286, 7, 4, 0, 0, 5286, 5287, 5, 95, 0, 0, 5287, 5288, + 7, 11, 0, 0, 5288, 5289, 7, 15, 0, 0, 5289, 5290, 7, 13, 0, 0, 5290, 5291, + 7, 7, 0, 0, 5291, 684, 1, 0, 0, 0, 5292, 5293, 7, 3, 0, 0, 5293, 5294, + 7, 17, 0, 0, 5294, 5295, 7, 6, 0, 0, 5295, 5296, 7, 19, 0, 0, 5296, 5297, + 5, 95, 0, 0, 5297, 5298, 7, 15, 0, 0, 5298, 5299, 7, 12, 0, 0, 5299, 5300, + 7, 14, 0, 0, 5300, 5301, 7, 8, 0, 0, 5301, 5302, 7, 7, 0, 0, 5302, 5303, + 7, 23, 0, 0, 5303, 5304, 7, 7, 0, 0, 5304, 5305, 7, 12, 0, 0, 5305, 5306, + 7, 6, 0, 0, 5306, 686, 1, 0, 0, 0, 5307, 5308, 7, 3, 0, 0, 5308, 5309, + 7, 24, 0, 0, 5309, 5310, 7, 22, 0, 0, 5310, 5311, 5, 95, 0, 0, 5311, 5312, + 7, 8, 0, 0, 5312, 5313, 7, 19, 0, 0, 5313, 5314, 7, 9, 0, 0, 5314, 5315, + 5, 95, 0, 0, 5315, 5316, 7, 5, 0, 0, 5316, 5317, 7, 7, 0, 0, 5317, 5318, + 7, 12, 0, 0, 5318, 5319, 7, 22, 0, 0, 5319, 5320, 7, 6, 0, 0, 5320, 5321, + 7, 20, 0, 0, 5321, 688, 1, 0, 0, 0, 5322, 5323, 7, 16, 0, 0, 5323, 5324, + 7, 7, 0, 0, 5324, 5325, 7, 22, 0, 0, 5325, 5326, 7, 15, 0, 0, 5326, 5327, + 7, 12, 0, 0, 5327, 690, 1, 0, 0, 0, 5328, 5329, 7, 16, 0, 0, 5329, 5330, + 7, 15, 0, 0, 5330, 5331, 7, 12, 0, 0, 5331, 5332, 7, 5, 0, 0, 5332, 5333, + 7, 19, 0, 0, 5333, 5334, 7, 22, 0, 0, 5334, 692, 1, 0, 0, 0, 5335, 5336, + 7, 16, 0, 0, 5336, 5337, 7, 15, 0, 0, 5337, 5338, 7, 6, 0, 0, 5338, 694, + 1, 0, 0, 0, 5339, 5340, 7, 16, 0, 0, 5340, 5341, 7, 5, 0, 0, 5341, 5342, + 7, 19, 0, 0, 5342, 5343, 7, 14, 0, 0, 5343, 5344, 7, 21, 0, 0, 5344, 696, + 1, 0, 0, 0, 5345, 5346, 7, 16, 0, 0, 5346, 5347, 7, 19, 0, 0, 5347, 5348, + 7, 19, 0, 0, 5348, 5349, 7, 5, 0, 0, 5349, 698, 1, 0, 0, 0, 5350, 5351, + 7, 16, 0, 0, 5351, 5352, 7, 19, 0, 0, 5352, 5353, 7, 19, 0, 0, 5353, 5354, + 7, 5, 0, 0, 5354, 5355, 7, 7, 0, 0, 5355, 5356, 7, 3, 0, 0, 5356, 5357, + 7, 12, 0, 0, 5357, 700, 1, 0, 0, 0, 5358, 5359, 7, 16, 0, 0, 5359, 5360, + 7, 6, 0, 0, 5360, 5361, 7, 8, 0, 0, 5361, 5362, 7, 7, 0, 0, 5362, 5363, + 7, 7, 0, 0, 5363, 702, 1, 0, 0, 0, 5364, 5365, 7, 14, 0, 0, 5365, 5366, + 7, 3, 0, 0, 5366, 5367, 7, 14, 0, 0, 5367, 5368, 7, 20, 0, 0, 5368, 5369, + 7, 7, 0, 0, 5369, 704, 1, 0, 0, 0, 5370, 5371, 7, 14, 0, 0, 5371, 5372, + 7, 3, 0, 0, 5372, 5373, 7, 11, 0, 0, 5373, 5374, 7, 14, 0, 0, 5374, 5375, + 7, 3, 0, 0, 5375, 5376, 7, 4, 0, 0, 5376, 5377, 7, 7, 0, 0, 5377, 5378, + 7, 4, 0, 0, 5378, 706, 1, 0, 0, 0, 5379, 5380, 7, 14, 0, 0, 5380, 5381, + 7, 20, 0, 0, 5381, 5382, 7, 3, 0, 0, 5382, 5383, 7, 15, 0, 0, 5383, 5384, + 7, 12, 0, 0, 5384, 708, 1, 0, 0, 0, 5385, 5386, 7, 14, 0, 0, 5386, 5387, + 7, 20, 0, 0, 5387, 5388, 7, 3, 0, 0, 5388, 5389, 7, 12, 0, 0, 5389, 5390, + 7, 22, 0, 0, 5390, 5391, 7, 7, 0, 0, 5391, 5392, 7, 4, 0, 0, 5392, 710, + 1, 0, 0, 0, 5393, 5394, 7, 14, 0, 0, 5394, 5395, 7, 20, 0, 0, 5395, 5396, + 7, 3, 0, 0, 5396, 5397, 7, 12, 0, 0, 5397, 5398, 7, 12, 0, 0, 5398, 5399, + 7, 7, 0, 0, 5399, 5400, 7, 5, 0, 0, 5400, 712, 1, 0, 0, 0, 5401, 5402, + 7, 14, 0, 0, 5402, 5403, 7, 20, 0, 0, 5403, 5404, 7, 7, 0, 0, 5404, 5405, + 7, 14, 0, 0, 5405, 5406, 7, 21, 0, 0, 5406, 5407, 7, 11, 0, 0, 5407, 5408, + 7, 17, 0, 0, 5408, 5409, 7, 23, 0, 0, 5409, 714, 1, 0, 0, 0, 5410, 5411, + 7, 25, 0, 0, 5411, 5412, 7, 3, 0, 0, 5412, 5413, 7, 22, 0, 0, 5413, 5414, + 7, 7, 0, 0, 5414, 5415, 5, 95, 0, 0, 5415, 5416, 7, 14, 0, 0, 5416, 5417, + 7, 20, 0, 0, 5417, 5418, 7, 7, 0, 0, 5418, 5419, 7, 14, 0, 0, 5419, 5420, + 7, 21, 0, 0, 5420, 5421, 7, 11, 0, 0, 5421, 5422, 7, 17, 0, 0, 5422, 5423, + 7, 23, 0, 0, 5423, 716, 1, 0, 0, 0, 5424, 5425, 7, 14, 0, 0, 5425, 5426, + 7, 15, 0, 0, 5426, 5427, 7, 25, 0, 0, 5427, 5428, 7, 20, 0, 0, 5428, 5429, + 7, 7, 0, 0, 5429, 5430, 7, 8, 0, 0, 5430, 718, 1, 0, 0, 0, 5431, 5432, + 7, 14, 0, 0, 5432, 5433, 7, 5, 0, 0, 5433, 5434, 7, 3, 0, 0, 5434, 5435, + 7, 11, 0, 0, 5435, 5436, 7, 11, 0, 0, 5436, 5437, 5, 95, 0, 0, 5437, 5438, + 7, 19, 0, 0, 5438, 5439, 7, 8, 0, 0, 5439, 5440, 7, 15, 0, 0, 5440, 5441, + 7, 22, 0, 0, 5441, 5442, 7, 15, 0, 0, 5442, 5443, 7, 12, 0, 0, 5443, 720, + 1, 0, 0, 0, 5444, 5445, 7, 14, 0, 0, 5445, 5446, 7, 5, 0, 0, 5446, 5447, + 7, 15, 0, 0, 5447, 5448, 7, 7, 0, 0, 5448, 5449, 7, 12, 0, 0, 5449, 5450, + 7, 6, 0, 0, 5450, 722, 1, 0, 0, 0, 5451, 5452, 7, 14, 0, 0, 5452, 5453, + 7, 5, 0, 0, 5453, 5454, 7, 19, 0, 0, 5454, 5455, 7, 11, 0, 0, 5455, 5456, + 7, 7, 0, 0, 5456, 724, 1, 0, 0, 0, 5457, 5458, 7, 14, 0, 0, 5458, 5459, + 7, 5, 0, 0, 5459, 5460, 7, 17, 0, 0, 5460, 5461, 7, 11, 0, 0, 5461, 5462, + 7, 6, 0, 0, 5462, 5463, 7, 7, 0, 0, 5463, 5464, 7, 8, 0, 0, 5464, 5465, + 7, 15, 0, 0, 5465, 5466, 7, 12, 0, 0, 5466, 5467, 7, 22, 0, 0, 5467, 726, + 1, 0, 0, 0, 5468, 5469, 7, 14, 0, 0, 5469, 5470, 7, 19, 0, 0, 5470, 5471, + 7, 3, 0, 0, 5471, 5472, 7, 5, 0, 0, 5472, 5473, 7, 7, 0, 0, 5473, 5474, + 7, 11, 0, 0, 5474, 5475, 7, 14, 0, 0, 5475, 5476, 7, 7, 0, 0, 5476, 728, + 1, 0, 0, 0, 5477, 5478, 7, 14, 0, 0, 5478, 5479, 7, 19, 0, 0, 5479, 5480, + 7, 4, 0, 0, 5480, 5481, 7, 7, 0, 0, 5481, 730, 1, 0, 0, 0, 5482, 5483, + 7, 14, 0, 0, 5483, 5484, 7, 19, 0, 0, 5484, 5485, 7, 5, 0, 0, 5485, 5486, + 7, 17, 0, 0, 5486, 5487, 7, 23, 0, 0, 5487, 5488, 7, 12, 0, 0, 5488, 5489, + 7, 11, 0, 0, 5489, 732, 1, 0, 0, 0, 5490, 5491, 7, 14, 0, 0, 5491, 5492, + 7, 19, 0, 0, 5492, 5493, 7, 5, 0, 0, 5493, 5494, 7, 17, 0, 0, 5494, 5495, + 7, 23, 0, 0, 5495, 5496, 7, 12, 0, 0, 5496, 5497, 5, 95, 0, 0, 5497, 5498, + 7, 18, 0, 0, 5498, 5499, 7, 19, 0, 0, 5499, 5500, 7, 8, 0, 0, 5500, 5501, + 7, 23, 0, 0, 5501, 5502, 7, 3, 0, 0, 5502, 5503, 7, 6, 0, 0, 5503, 734, + 1, 0, 0, 0, 5504, 5505, 7, 14, 0, 0, 5505, 5506, 7, 19, 0, 0, 5506, 5507, + 7, 5, 0, 0, 5507, 5508, 7, 17, 0, 0, 5508, 5509, 7, 23, 0, 0, 5509, 5510, + 7, 12, 0, 0, 5510, 5511, 5, 95, 0, 0, 5511, 5512, 7, 12, 0, 0, 5512, 5513, + 7, 3, 0, 0, 5513, 5514, 7, 23, 0, 0, 5514, 5515, 7, 7, 0, 0, 5515, 736, + 1, 0, 0, 0, 5516, 5517, 7, 14, 0, 0, 5517, 5518, 7, 19, 0, 0, 5518, 5519, + 7, 23, 0, 0, 5519, 5520, 7, 23, 0, 0, 5520, 5521, 7, 7, 0, 0, 5521, 5522, + 7, 12, 0, 0, 5522, 5523, 7, 6, 0, 0, 5523, 738, 1, 0, 0, 0, 5524, 5525, + 7, 14, 0, 0, 5525, 5526, 7, 19, 0, 0, 5526, 5527, 7, 23, 0, 0, 5527, 5528, + 7, 23, 0, 0, 5528, 5529, 7, 15, 0, 0, 5529, 5530, 7, 6, 0, 0, 5530, 740, + 1, 0, 0, 0, 5531, 5532, 7, 14, 0, 0, 5532, 5533, 7, 19, 0, 0, 5533, 5534, + 7, 23, 0, 0, 5534, 5535, 7, 25, 0, 0, 5535, 5536, 7, 3, 0, 0, 5536, 5537, + 7, 14, 0, 0, 5537, 5538, 7, 6, 0, 0, 5538, 742, 1, 0, 0, 0, 5539, 5540, + 7, 14, 0, 0, 5540, 5541, 7, 19, 0, 0, 5541, 5542, 7, 23, 0, 0, 5542, 5543, + 7, 25, 0, 0, 5543, 5544, 7, 5, 0, 0, 5544, 5545, 7, 7, 0, 0, 5545, 5546, + 7, 6, 0, 0, 5546, 5547, 7, 15, 0, 0, 5547, 5548, 7, 19, 0, 0, 5548, 5549, + 7, 12, 0, 0, 5549, 744, 1, 0, 0, 0, 5550, 5551, 7, 14, 0, 0, 5551, 5552, + 7, 19, 0, 0, 5552, 5553, 7, 23, 0, 0, 5553, 5554, 7, 25, 0, 0, 5554, 5555, + 7, 8, 0, 0, 5555, 5556, 7, 7, 0, 0, 5556, 5557, 7, 11, 0, 0, 5557, 5558, + 7, 11, 0, 0, 5558, 5559, 7, 7, 0, 0, 5559, 5560, 7, 4, 0, 0, 5560, 746, + 1, 0, 0, 0, 5561, 5562, 7, 14, 0, 0, 5562, 5563, 7, 19, 0, 0, 5563, 5564, + 7, 23, 0, 0, 5564, 5565, 7, 25, 0, 0, 5565, 5566, 7, 8, 0, 0, 5566, 5567, + 7, 7, 0, 0, 5567, 5568, 7, 11, 0, 0, 5568, 5569, 7, 11, 0, 0, 5569, 5570, + 7, 15, 0, 0, 5570, 5571, 7, 19, 0, 0, 5571, 5572, 7, 12, 0, 0, 5572, 748, + 1, 0, 0, 0, 5573, 5574, 7, 14, 0, 0, 5574, 5575, 7, 19, 0, 0, 5575, 5576, + 7, 12, 0, 0, 5576, 5577, 7, 14, 0, 0, 5577, 5578, 7, 17, 0, 0, 5578, 5579, + 7, 8, 0, 0, 5579, 5580, 7, 8, 0, 0, 5580, 5581, 7, 7, 0, 0, 5581, 5582, + 7, 12, 0, 0, 5582, 5583, 7, 6, 0, 0, 5583, 750, 1, 0, 0, 0, 5584, 5585, + 7, 14, 0, 0, 5585, 5586, 7, 19, 0, 0, 5586, 5587, 7, 12, 0, 0, 5587, 5588, + 7, 12, 0, 0, 5588, 5589, 7, 7, 0, 0, 5589, 5590, 7, 14, 0, 0, 5590, 5591, + 7, 6, 0, 0, 5591, 752, 1, 0, 0, 0, 5592, 5593, 7, 14, 0, 0, 5593, 5594, + 7, 19, 0, 0, 5594, 5595, 7, 12, 0, 0, 5595, 5596, 7, 12, 0, 0, 5596, 5597, + 7, 7, 0, 0, 5597, 5598, 7, 14, 0, 0, 5598, 5599, 7, 6, 0, 0, 5599, 5600, + 7, 15, 0, 0, 5600, 5601, 7, 19, 0, 0, 5601, 5602, 7, 12, 0, 0, 5602, 754, + 1, 0, 0, 0, 5603, 5604, 7, 14, 0, 0, 5604, 5605, 7, 19, 0, 0, 5605, 5606, + 7, 12, 0, 0, 5606, 5607, 7, 11, 0, 0, 5607, 5608, 7, 15, 0, 0, 5608, 5609, + 7, 11, 0, 0, 5609, 5610, 7, 6, 0, 0, 5610, 5611, 7, 7, 0, 0, 5611, 5612, + 7, 12, 0, 0, 5612, 5613, 7, 6, 0, 0, 5613, 756, 1, 0, 0, 0, 5614, 5615, + 7, 14, 0, 0, 5615, 5616, 7, 19, 0, 0, 5616, 5617, 7, 12, 0, 0, 5617, 5618, + 7, 11, 0, 0, 5618, 5619, 7, 6, 0, 0, 5619, 5620, 7, 8, 0, 0, 5620, 5621, + 7, 3, 0, 0, 5621, 5622, 7, 15, 0, 0, 5622, 5623, 7, 12, 0, 0, 5623, 5624, + 7, 6, 0, 0, 5624, 5625, 5, 95, 0, 0, 5625, 5626, 7, 14, 0, 0, 5626, 5627, + 7, 3, 0, 0, 5627, 5628, 7, 6, 0, 0, 5628, 5629, 7, 3, 0, 0, 5629, 5630, + 7, 5, 0, 0, 5630, 5631, 7, 19, 0, 0, 5631, 5632, 7, 22, 0, 0, 5632, 758, + 1, 0, 0, 0, 5633, 5634, 7, 14, 0, 0, 5634, 5635, 7, 19, 0, 0, 5635, 5636, + 7, 12, 0, 0, 5636, 5637, 7, 11, 0, 0, 5637, 5638, 7, 6, 0, 0, 5638, 5639, + 7, 8, 0, 0, 5639, 5640, 7, 3, 0, 0, 5640, 5641, 7, 15, 0, 0, 5641, 5642, + 7, 12, 0, 0, 5642, 5643, 7, 6, 0, 0, 5643, 5644, 5, 95, 0, 0, 5644, 5645, + 7, 11, 0, 0, 5645, 5646, 7, 14, 0, 0, 5646, 5647, 7, 20, 0, 0, 5647, 5648, + 7, 7, 0, 0, 5648, 5649, 7, 23, 0, 0, 5649, 5650, 7, 3, 0, 0, 5650, 760, + 1, 0, 0, 0, 5651, 5652, 7, 14, 0, 0, 5652, 5653, 7, 19, 0, 0, 5653, 5654, + 7, 12, 0, 0, 5654, 5655, 7, 11, 0, 0, 5655, 5656, 7, 6, 0, 0, 5656, 5657, + 7, 8, 0, 0, 5657, 5658, 7, 3, 0, 0, 5658, 5659, 7, 15, 0, 0, 5659, 5660, + 7, 12, 0, 0, 5660, 5661, 7, 6, 0, 0, 5661, 5662, 5, 95, 0, 0, 5662, 5663, + 7, 12, 0, 0, 5663, 5664, 7, 3, 0, 0, 5664, 5665, 7, 23, 0, 0, 5665, 5666, + 7, 7, 0, 0, 5666, 762, 1, 0, 0, 0, 5667, 5668, 7, 14, 0, 0, 5668, 5669, + 7, 19, 0, 0, 5669, 5670, 7, 12, 0, 0, 5670, 5671, 7, 6, 0, 0, 5671, 5672, + 7, 3, 0, 0, 5672, 5673, 7, 15, 0, 0, 5673, 5674, 7, 12, 0, 0, 5674, 5675, + 7, 11, 0, 0, 5675, 764, 1, 0, 0, 0, 5676, 5677, 7, 14, 0, 0, 5677, 5678, + 7, 19, 0, 0, 5678, 5679, 7, 12, 0, 0, 5679, 5680, 7, 6, 0, 0, 5680, 5681, + 7, 7, 0, 0, 5681, 5682, 7, 26, 0, 0, 5682, 5683, 7, 6, 0, 0, 5683, 766, + 1, 0, 0, 0, 5684, 5685, 7, 14, 0, 0, 5685, 5686, 7, 19, 0, 0, 5686, 5687, + 7, 12, 0, 0, 5687, 5688, 7, 6, 0, 0, 5688, 5689, 7, 8, 0, 0, 5689, 5690, + 7, 15, 0, 0, 5690, 5691, 7, 16, 0, 0, 5691, 5692, 7, 17, 0, 0, 5692, 5693, + 7, 6, 0, 0, 5693, 5694, 7, 19, 0, 0, 5694, 5695, 7, 8, 0, 0, 5695, 5696, + 7, 11, 0, 0, 5696, 768, 1, 0, 0, 0, 5697, 5698, 7, 14, 0, 0, 5698, 5699, + 7, 19, 0, 0, 5699, 5700, 7, 25, 0, 0, 5700, 5701, 7, 10, 0, 0, 5701, 770, + 1, 0, 0, 0, 5702, 5703, 7, 14, 0, 0, 5703, 5704, 7, 25, 0, 0, 5704, 5705, + 7, 17, 0, 0, 5705, 772, 1, 0, 0, 0, 5706, 5707, 7, 14, 0, 0, 5707, 5708, + 7, 10, 0, 0, 5708, 5709, 7, 14, 0, 0, 5709, 5710, 7, 5, 0, 0, 5710, 5711, + 7, 7, 0, 0, 5711, 774, 1, 0, 0, 0, 5712, 5713, 7, 14, 0, 0, 5713, 5714, + 7, 17, 0, 0, 5714, 5715, 7, 8, 0, 0, 5715, 5716, 7, 11, 0, 0, 5716, 5717, + 7, 19, 0, 0, 5717, 5718, 7, 8, 0, 0, 5718, 5719, 5, 95, 0, 0, 5719, 5720, + 7, 12, 0, 0, 5720, 5721, 7, 3, 0, 0, 5721, 5722, 7, 23, 0, 0, 5722, 5723, + 7, 7, 0, 0, 5723, 776, 1, 0, 0, 0, 5724, 5725, 7, 4, 0, 0, 5725, 5726, + 7, 3, 0, 0, 5726, 5727, 7, 6, 0, 0, 5727, 5728, 7, 3, 0, 0, 5728, 778, + 1, 0, 0, 0, 5729, 5730, 7, 4, 0, 0, 5730, 5731, 7, 3, 0, 0, 5731, 5732, + 7, 6, 0, 0, 5732, 5733, 7, 3, 0, 0, 5733, 5734, 7, 18, 0, 0, 5734, 5735, + 7, 15, 0, 0, 5735, 5736, 7, 5, 0, 0, 5736, 5737, 7, 7, 0, 0, 5737, 780, + 1, 0, 0, 0, 5738, 5739, 7, 4, 0, 0, 5739, 5740, 7, 7, 0, 0, 5740, 5741, + 7, 3, 0, 0, 5741, 5742, 7, 5, 0, 0, 5742, 5743, 7, 5, 0, 0, 5743, 5744, + 7, 19, 0, 0, 5744, 5745, 7, 14, 0, 0, 5745, 5746, 7, 3, 0, 0, 5746, 5747, + 7, 6, 0, 0, 5747, 5748, 7, 7, 0, 0, 5748, 782, 1, 0, 0, 0, 5749, 5750, + 7, 4, 0, 0, 5750, 5751, 7, 7, 0, 0, 5751, 5752, 7, 18, 0, 0, 5752, 5753, + 7, 3, 0, 0, 5753, 5754, 7, 17, 0, 0, 5754, 5755, 7, 5, 0, 0, 5755, 5756, + 7, 6, 0, 0, 5756, 5757, 5, 95, 0, 0, 5757, 5758, 7, 3, 0, 0, 5758, 5759, + 7, 17, 0, 0, 5759, 5760, 7, 6, 0, 0, 5760, 5761, 7, 20, 0, 0, 5761, 784, + 1, 0, 0, 0, 5762, 5763, 7, 4, 0, 0, 5763, 5764, 7, 7, 0, 0, 5764, 5765, + 7, 18, 0, 0, 5765, 5766, 7, 15, 0, 0, 5766, 5767, 7, 12, 0, 0, 5767, 5768, + 7, 7, 0, 0, 5768, 5769, 7, 8, 0, 0, 5769, 786, 1, 0, 0, 0, 5770, 5771, + 7, 4, 0, 0, 5771, 5772, 7, 7, 0, 0, 5772, 5773, 7, 5, 0, 0, 5773, 5774, + 7, 3, 0, 0, 5774, 5775, 7, 10, 0, 0, 5775, 5776, 5, 95, 0, 0, 5776, 5777, + 7, 21, 0, 0, 5777, 5778, 7, 7, 0, 0, 5778, 5779, 7, 10, 0, 0, 5779, 5780, + 5, 95, 0, 0, 5780, 5781, 7, 9, 0, 0, 5781, 5782, 7, 8, 0, 0, 5782, 5783, + 7, 15, 0, 0, 5783, 5784, 7, 6, 0, 0, 5784, 5785, 7, 7, 0, 0, 5785, 788, + 1, 0, 0, 0, 5786, 5787, 7, 4, 0, 0, 5787, 5788, 7, 7, 0, 0, 5788, 5789, + 7, 11, 0, 0, 5789, 5790, 5, 95, 0, 0, 5790, 5791, 7, 21, 0, 0, 5791, 5792, + 7, 7, 0, 0, 5792, 5793, 7, 10, 0, 0, 5793, 5794, 5, 95, 0, 0, 5794, 5795, + 7, 18, 0, 0, 5795, 5796, 7, 15, 0, 0, 5796, 5797, 7, 5, 0, 0, 5797, 5798, + 7, 7, 0, 0, 5798, 790, 1, 0, 0, 0, 5799, 5800, 7, 4, 0, 0, 5800, 5801, + 7, 15, 0, 0, 5801, 5802, 7, 8, 0, 0, 5802, 5803, 7, 7, 0, 0, 5803, 5804, + 7, 14, 0, 0, 5804, 5805, 7, 6, 0, 0, 5805, 5806, 7, 19, 0, 0, 5806, 5807, + 7, 8, 0, 0, 5807, 5808, 7, 10, 0, 0, 5808, 792, 1, 0, 0, 0, 5809, 5810, + 7, 4, 0, 0, 5810, 5811, 7, 15, 0, 0, 5811, 5812, 7, 11, 0, 0, 5812, 5813, + 7, 3, 0, 0, 5813, 5814, 7, 16, 0, 0, 5814, 5815, 7, 5, 0, 0, 5815, 5816, + 7, 7, 0, 0, 5816, 794, 1, 0, 0, 0, 5817, 5818, 7, 4, 0, 0, 5818, 5819, + 7, 15, 0, 0, 5819, 5820, 7, 11, 0, 0, 5820, 5821, 7, 14, 0, 0, 5821, 5822, + 7, 3, 0, 0, 5822, 5823, 7, 8, 0, 0, 5823, 5824, 7, 4, 0, 0, 5824, 796, + 1, 0, 0, 0, 5825, 5826, 7, 4, 0, 0, 5826, 5827, 7, 15, 0, 0, 5827, 5828, + 7, 11, 0, 0, 5828, 5829, 7, 21, 0, 0, 5829, 798, 1, 0, 0, 0, 5830, 5831, + 7, 4, 0, 0, 5831, 5832, 7, 19, 0, 0, 5832, 800, 1, 0, 0, 0, 5833, 5834, + 7, 4, 0, 0, 5834, 5835, 7, 17, 0, 0, 5835, 5836, 7, 23, 0, 0, 5836, 5837, + 7, 25, 0, 0, 5837, 5838, 7, 18, 0, 0, 5838, 5839, 7, 15, 0, 0, 5839, 5840, + 7, 5, 0, 0, 5840, 5841, 7, 7, 0, 0, 5841, 802, 1, 0, 0, 0, 5842, 5843, + 7, 4, 0, 0, 5843, 5844, 7, 17, 0, 0, 5844, 5845, 7, 25, 0, 0, 5845, 5846, + 7, 5, 0, 0, 5846, 5847, 7, 15, 0, 0, 5847, 5848, 7, 14, 0, 0, 5848, 5849, + 7, 3, 0, 0, 5849, 5850, 7, 6, 0, 0, 5850, 5851, 7, 7, 0, 0, 5851, 804, + 1, 0, 0, 0, 5852, 5853, 7, 4, 0, 0, 5853, 5854, 7, 10, 0, 0, 5854, 5855, + 7, 12, 0, 0, 5855, 5856, 7, 3, 0, 0, 5856, 5857, 7, 23, 0, 0, 5857, 5858, + 7, 15, 0, 0, 5858, 5859, 7, 14, 0, 0, 5859, 806, 1, 0, 0, 0, 5860, 5861, + 7, 7, 0, 0, 5861, 5862, 7, 12, 0, 0, 5862, 5863, 7, 3, 0, 0, 5863, 5864, + 7, 16, 0, 0, 5864, 5865, 7, 5, 0, 0, 5865, 5866, 7, 7, 0, 0, 5866, 808, + 1, 0, 0, 0, 5867, 5868, 7, 7, 0, 0, 5868, 5869, 7, 12, 0, 0, 5869, 5870, + 7, 14, 0, 0, 5870, 5871, 7, 8, 0, 0, 5871, 5872, 7, 10, 0, 0, 5872, 5873, + 7, 25, 0, 0, 5873, 5874, 7, 6, 0, 0, 5874, 5875, 7, 7, 0, 0, 5875, 5876, + 7, 4, 0, 0, 5876, 810, 1, 0, 0, 0, 5877, 5878, 7, 7, 0, 0, 5878, 5879, + 7, 12, 0, 0, 5879, 5880, 7, 14, 0, 0, 5880, 5881, 7, 8, 0, 0, 5881, 5882, + 7, 10, 0, 0, 5882, 5883, 7, 25, 0, 0, 5883, 5884, 7, 6, 0, 0, 5884, 5885, + 7, 15, 0, 0, 5885, 5886, 7, 19, 0, 0, 5886, 5887, 7, 12, 0, 0, 5887, 812, + 1, 0, 0, 0, 5888, 5889, 7, 7, 0, 0, 5889, 5890, 7, 12, 0, 0, 5890, 5891, + 7, 14, 0, 0, 5891, 5892, 7, 8, 0, 0, 5892, 5893, 7, 10, 0, 0, 5893, 5894, + 7, 25, 0, 0, 5894, 5895, 7, 6, 0, 0, 5895, 5896, 7, 15, 0, 0, 5896, 5897, + 7, 19, 0, 0, 5897, 5898, 7, 12, 0, 0, 5898, 5899, 5, 95, 0, 0, 5899, 5900, + 7, 21, 0, 0, 5900, 5901, 7, 7, 0, 0, 5901, 5902, 7, 10, 0, 0, 5902, 5903, + 5, 95, 0, 0, 5903, 5904, 7, 15, 0, 0, 5904, 5905, 7, 4, 0, 0, 5905, 814, + 1, 0, 0, 0, 5906, 5907, 7, 7, 0, 0, 5907, 5908, 7, 12, 0, 0, 5908, 5909, + 7, 4, 0, 0, 5909, 816, 1, 0, 0, 0, 5910, 5911, 7, 7, 0, 0, 5911, 5912, + 7, 12, 0, 0, 5912, 5913, 7, 4, 0, 0, 5913, 5914, 7, 11, 0, 0, 5914, 818, + 1, 0, 0, 0, 5915, 5916, 7, 7, 0, 0, 5916, 5917, 7, 12, 0, 0, 5917, 5918, + 7, 22, 0, 0, 5918, 5919, 7, 15, 0, 0, 5919, 5920, 7, 12, 0, 0, 5920, 5921, + 7, 7, 0, 0, 5921, 820, 1, 0, 0, 0, 5922, 5923, 7, 7, 0, 0, 5923, 5924, + 7, 12, 0, 0, 5924, 5925, 7, 22, 0, 0, 5925, 5926, 7, 15, 0, 0, 5926, 5927, + 7, 12, 0, 0, 5927, 5928, 7, 7, 0, 0, 5928, 5929, 7, 11, 0, 0, 5929, 822, + 1, 0, 0, 0, 5930, 5931, 7, 7, 0, 0, 5931, 5932, 7, 8, 0, 0, 5932, 5933, + 7, 8, 0, 0, 5933, 5934, 7, 19, 0, 0, 5934, 5935, 7, 8, 0, 0, 5935, 824, + 1, 0, 0, 0, 5936, 5937, 7, 7, 0, 0, 5937, 5938, 7, 8, 0, 0, 5938, 5939, + 7, 8, 0, 0, 5939, 5940, 7, 19, 0, 0, 5940, 5941, 7, 8, 0, 0, 5941, 5942, + 7, 11, 0, 0, 5942, 826, 1, 0, 0, 0, 5943, 5944, 7, 7, 0, 0, 5944, 5945, + 7, 11, 0, 0, 5945, 5946, 7, 14, 0, 0, 5946, 5947, 7, 3, 0, 0, 5947, 5948, + 7, 25, 0, 0, 5948, 5949, 7, 7, 0, 0, 5949, 828, 1, 0, 0, 0, 5950, 5951, + 7, 7, 0, 0, 5951, 5952, 7, 24, 0, 0, 5952, 5953, 7, 7, 0, 0, 5953, 5954, + 7, 12, 0, 0, 5954, 830, 1, 0, 0, 0, 5955, 5956, 7, 7, 0, 0, 5956, 5957, + 7, 24, 0, 0, 5957, 5958, 7, 7, 0, 0, 5958, 5959, 7, 12, 0, 0, 5959, 5960, + 7, 6, 0, 0, 5960, 832, 1, 0, 0, 0, 5961, 5962, 7, 7, 0, 0, 5962, 5963, + 7, 24, 0, 0, 5963, 5964, 7, 7, 0, 0, 5964, 5965, 7, 12, 0, 0, 5965, 5966, + 7, 6, 0, 0, 5966, 5967, 7, 11, 0, 0, 5967, 834, 1, 0, 0, 0, 5968, 5969, + 7, 7, 0, 0, 5969, 5970, 7, 24, 0, 0, 5970, 5971, 7, 7, 0, 0, 5971, 5972, + 7, 8, 0, 0, 5972, 5973, 7, 10, 0, 0, 5973, 836, 1, 0, 0, 0, 5974, 5975, + 7, 7, 0, 0, 5975, 5976, 7, 26, 0, 0, 5976, 5977, 7, 14, 0, 0, 5977, 5978, + 7, 20, 0, 0, 5978, 5979, 7, 3, 0, 0, 5979, 5980, 7, 12, 0, 0, 5980, 5981, + 7, 22, 0, 0, 5981, 5982, 7, 7, 0, 0, 5982, 838, 1, 0, 0, 0, 5983, 5984, + 7, 7, 0, 0, 5984, 5985, 7, 26, 0, 0, 5985, 5986, 7, 14, 0, 0, 5986, 5987, + 7, 5, 0, 0, 5987, 5988, 7, 17, 0, 0, 5988, 5989, 7, 11, 0, 0, 5989, 5990, + 7, 15, 0, 0, 5990, 5991, 7, 24, 0, 0, 5991, 5992, 7, 7, 0, 0, 5992, 840, + 1, 0, 0, 0, 5993, 5994, 7, 7, 0, 0, 5994, 5995, 7, 26, 0, 0, 5995, 5996, + 7, 25, 0, 0, 5996, 5997, 7, 15, 0, 0, 5997, 5998, 7, 8, 0, 0, 5998, 5999, + 7, 7, 0, 0, 5999, 842, 1, 0, 0, 0, 6000, 6001, 7, 7, 0, 0, 6001, 6002, + 7, 26, 0, 0, 6002, 6003, 7, 25, 0, 0, 6003, 6004, 7, 19, 0, 0, 6004, 6005, + 7, 8, 0, 0, 6005, 6006, 7, 6, 0, 0, 6006, 844, 1, 0, 0, 0, 6007, 6008, + 7, 7, 0, 0, 6008, 6009, 7, 26, 0, 0, 6009, 6010, 7, 6, 0, 0, 6010, 6011, + 7, 7, 0, 0, 6011, 6012, 7, 12, 0, 0, 6012, 6013, 7, 4, 0, 0, 6013, 6014, + 7, 7, 0, 0, 6014, 6015, 7, 4, 0, 0, 6015, 846, 1, 0, 0, 0, 6016, 6017, + 7, 7, 0, 0, 6017, 6018, 7, 26, 0, 0, 6018, 6019, 7, 6, 0, 0, 6019, 6020, + 7, 7, 0, 0, 6020, 6021, 7, 12, 0, 0, 6021, 6022, 7, 6, 0, 0, 6022, 6023, + 5, 95, 0, 0, 6023, 6024, 7, 11, 0, 0, 6024, 6025, 7, 15, 0, 0, 6025, 6026, + 7, 13, 0, 0, 6026, 6027, 7, 7, 0, 0, 6027, 848, 1, 0, 0, 0, 6028, 6029, + 7, 18, 0, 0, 6029, 6030, 7, 3, 0, 0, 6030, 6031, 7, 15, 0, 0, 6031, 6032, + 7, 5, 0, 0, 6032, 6033, 7, 7, 0, 0, 6033, 6034, 7, 4, 0, 0, 6034, 6035, + 5, 95, 0, 0, 6035, 6036, 7, 5, 0, 0, 6036, 6037, 7, 19, 0, 0, 6037, 6038, + 7, 22, 0, 0, 6038, 6039, 7, 15, 0, 0, 6039, 6040, 7, 12, 0, 0, 6040, 6041, + 5, 95, 0, 0, 6041, 6042, 7, 3, 0, 0, 6042, 6043, 7, 6, 0, 0, 6043, 6044, + 7, 6, 0, 0, 6044, 6045, 7, 7, 0, 0, 6045, 6046, 7, 23, 0, 0, 6046, 6047, + 7, 25, 0, 0, 6047, 6048, 7, 6, 0, 0, 6048, 6049, 7, 11, 0, 0, 6049, 850, + 1, 0, 0, 0, 6050, 6051, 7, 18, 0, 0, 6051, 6052, 7, 3, 0, 0, 6052, 6053, + 7, 11, 0, 0, 6053, 6054, 7, 6, 0, 0, 6054, 852, 1, 0, 0, 0, 6055, 6056, + 7, 18, 0, 0, 6056, 6057, 7, 3, 0, 0, 6057, 6058, 7, 17, 0, 0, 6058, 6059, + 7, 5, 0, 0, 6059, 6060, 7, 6, 0, 0, 6060, 6061, 7, 11, 0, 0, 6061, 854, + 1, 0, 0, 0, 6062, 6063, 7, 18, 0, 0, 6063, 6064, 7, 15, 0, 0, 6064, 6065, + 7, 7, 0, 0, 6065, 6066, 7, 5, 0, 0, 6066, 6067, 7, 4, 0, 0, 6067, 6068, + 7, 11, 0, 0, 6068, 856, 1, 0, 0, 0, 6069, 6070, 7, 18, 0, 0, 6070, 6071, + 7, 15, 0, 0, 6071, 6072, 7, 5, 0, 0, 6072, 6073, 7, 7, 0, 0, 6073, 6074, + 5, 95, 0, 0, 6074, 6075, 7, 16, 0, 0, 6075, 6076, 7, 5, 0, 0, 6076, 6077, + 7, 19, 0, 0, 6077, 6078, 7, 14, 0, 0, 6078, 6079, 7, 21, 0, 0, 6079, 6080, + 5, 95, 0, 0, 6080, 6081, 7, 11, 0, 0, 6081, 6082, 7, 15, 0, 0, 6082, 6083, + 7, 13, 0, 0, 6083, 6084, 7, 7, 0, 0, 6084, 858, 1, 0, 0, 0, 6085, 6086, + 7, 18, 0, 0, 6086, 6087, 7, 15, 0, 0, 6087, 6088, 7, 5, 0, 0, 6088, 6089, + 7, 6, 0, 0, 6089, 6090, 7, 7, 0, 0, 6090, 6091, 7, 8, 0, 0, 6091, 860, + 1, 0, 0, 0, 6092, 6093, 7, 18, 0, 0, 6093, 6094, 7, 15, 0, 0, 6094, 6095, + 7, 8, 0, 0, 6095, 6096, 7, 11, 0, 0, 6096, 6097, 7, 6, 0, 0, 6097, 862, + 1, 0, 0, 0, 6098, 6099, 7, 18, 0, 0, 6099, 6100, 7, 15, 0, 0, 6100, 6101, + 7, 26, 0, 0, 6101, 6102, 7, 7, 0, 0, 6102, 6103, 7, 4, 0, 0, 6103, 864, + 1, 0, 0, 0, 6104, 6105, 7, 18, 0, 0, 6105, 6106, 7, 5, 0, 0, 6106, 6107, + 7, 17, 0, 0, 6107, 6108, 7, 11, 0, 0, 6108, 6109, 7, 20, 0, 0, 6109, 866, + 1, 0, 0, 0, 6110, 6111, 7, 18, 0, 0, 6111, 6112, 7, 19, 0, 0, 6112, 6113, + 7, 5, 0, 0, 6113, 6114, 7, 5, 0, 0, 6114, 6115, 7, 19, 0, 0, 6115, 6116, + 7, 9, 0, 0, 6116, 6117, 7, 15, 0, 0, 6117, 6118, 7, 12, 0, 0, 6118, 6119, + 7, 22, 0, 0, 6119, 868, 1, 0, 0, 0, 6120, 6121, 7, 18, 0, 0, 6121, 6122, + 7, 19, 0, 0, 6122, 6123, 7, 5, 0, 0, 6123, 6124, 7, 5, 0, 0, 6124, 6125, + 7, 19, 0, 0, 6125, 6126, 7, 9, 0, 0, 6126, 6127, 7, 11, 0, 0, 6127, 870, + 1, 0, 0, 0, 6128, 6129, 7, 18, 0, 0, 6129, 6130, 7, 19, 0, 0, 6130, 6131, + 7, 17, 0, 0, 6131, 6132, 7, 12, 0, 0, 6132, 6133, 7, 4, 0, 0, 6133, 872, + 1, 0, 0, 0, 6134, 6135, 7, 18, 0, 0, 6135, 6136, 7, 17, 0, 0, 6136, 6137, + 7, 5, 0, 0, 6137, 6138, 7, 5, 0, 0, 6138, 874, 1, 0, 0, 0, 6139, 6140, + 7, 18, 0, 0, 6140, 6141, 7, 17, 0, 0, 6141, 6142, 7, 12, 0, 0, 6142, 6143, + 7, 14, 0, 0, 6143, 6144, 7, 6, 0, 0, 6144, 6145, 7, 15, 0, 0, 6145, 6146, + 7, 19, 0, 0, 6146, 6147, 7, 12, 0, 0, 6147, 876, 1, 0, 0, 0, 6148, 6149, + 7, 22, 0, 0, 6149, 6150, 7, 7, 0, 0, 6150, 6151, 7, 12, 0, 0, 6151, 6152, + 7, 7, 0, 0, 6152, 6153, 7, 8, 0, 0, 6153, 6154, 7, 3, 0, 0, 6154, 6155, + 7, 5, 0, 0, 6155, 878, 1, 0, 0, 0, 6156, 6157, 7, 22, 0, 0, 6157, 6158, + 7, 5, 0, 0, 6158, 6159, 7, 19, 0, 0, 6159, 6160, 7, 16, 0, 0, 6160, 6161, + 7, 3, 0, 0, 6161, 6162, 7, 5, 0, 0, 6162, 880, 1, 0, 0, 0, 6163, 6164, + 7, 22, 0, 0, 6164, 6165, 7, 8, 0, 0, 6165, 6166, 7, 3, 0, 0, 6166, 6167, + 7, 12, 0, 0, 6167, 6168, 7, 6, 0, 0, 6168, 6169, 7, 11, 0, 0, 6169, 882, + 1, 0, 0, 0, 6170, 6171, 7, 22, 0, 0, 6171, 6172, 7, 8, 0, 0, 6172, 6173, + 7, 19, 0, 0, 6173, 6174, 7, 17, 0, 0, 6174, 6175, 7, 25, 0, 0, 6175, 6176, + 5, 95, 0, 0, 6176, 6177, 7, 8, 0, 0, 6177, 6178, 7, 7, 0, 0, 6178, 6179, + 7, 25, 0, 0, 6179, 6180, 7, 5, 0, 0, 6180, 6181, 7, 15, 0, 0, 6181, 6182, + 7, 14, 0, 0, 6182, 6183, 7, 3, 0, 0, 6183, 6184, 7, 6, 0, 0, 6184, 6185, + 7, 15, 0, 0, 6185, 6186, 7, 19, 0, 0, 6186, 6187, 7, 12, 0, 0, 6187, 884, + 1, 0, 0, 0, 6188, 6189, 7, 20, 0, 0, 6189, 6190, 7, 3, 0, 0, 6190, 6191, + 7, 12, 0, 0, 6191, 6192, 7, 4, 0, 0, 6192, 6193, 7, 5, 0, 0, 6193, 6194, + 7, 7, 0, 0, 6194, 6195, 7, 8, 0, 0, 6195, 886, 1, 0, 0, 0, 6196, 6197, + 7, 20, 0, 0, 6197, 6198, 7, 3, 0, 0, 6198, 6199, 7, 11, 0, 0, 6199, 6200, + 7, 20, 0, 0, 6200, 888, 1, 0, 0, 0, 6201, 6202, 7, 20, 0, 0, 6202, 6203, + 7, 7, 0, 0, 6203, 6204, 7, 5, 0, 0, 6204, 6205, 7, 25, 0, 0, 6205, 890, + 1, 0, 0, 0, 6206, 6207, 7, 20, 0, 0, 6207, 6208, 7, 15, 0, 0, 6208, 6209, + 7, 11, 0, 0, 6209, 6210, 7, 6, 0, 0, 6210, 6211, 7, 19, 0, 0, 6211, 6212, + 7, 8, 0, 0, 6212, 6213, 7, 10, 0, 0, 6213, 892, 1, 0, 0, 0, 6214, 6215, + 7, 20, 0, 0, 6215, 6216, 7, 19, 0, 0, 6216, 6217, 7, 11, 0, 0, 6217, 6218, + 7, 6, 0, 0, 6218, 894, 1, 0, 0, 0, 6219, 6220, 7, 20, 0, 0, 6220, 6221, + 7, 19, 0, 0, 6221, 6222, 7, 11, 0, 0, 6222, 6223, 7, 6, 0, 0, 6223, 6224, + 7, 11, 0, 0, 6224, 896, 1, 0, 0, 0, 6225, 6226, 7, 15, 0, 0, 6226, 6227, + 7, 4, 0, 0, 6227, 6228, 7, 7, 0, 0, 6228, 6229, 7, 12, 0, 0, 6229, 6230, + 7, 6, 0, 0, 6230, 6231, 7, 15, 0, 0, 6231, 6232, 7, 18, 0, 0, 6232, 6233, + 7, 15, 0, 0, 6233, 6234, 7, 7, 0, 0, 6234, 6235, 7, 4, 0, 0, 6235, 898, + 1, 0, 0, 0, 6236, 6237, 7, 15, 0, 0, 6237, 6238, 7, 22, 0, 0, 6238, 6239, + 7, 12, 0, 0, 6239, 6240, 7, 19, 0, 0, 6240, 6241, 7, 8, 0, 0, 6241, 6242, + 7, 7, 0, 0, 6242, 6243, 5, 95, 0, 0, 6243, 6244, 7, 11, 0, 0, 6244, 6245, + 7, 7, 0, 0, 6245, 6246, 7, 8, 0, 0, 6246, 6247, 7, 24, 0, 0, 6247, 6248, + 7, 7, 0, 0, 6248, 6249, 7, 8, 0, 0, 6249, 6250, 5, 95, 0, 0, 6250, 6251, + 7, 15, 0, 0, 6251, 6252, 7, 4, 0, 0, 6252, 6253, 7, 11, 0, 0, 6253, 900, + 1, 0, 0, 0, 6254, 6255, 7, 15, 0, 0, 6255, 6256, 7, 23, 0, 0, 6256, 6257, + 7, 25, 0, 0, 6257, 6258, 7, 19, 0, 0, 6258, 6259, 7, 8, 0, 0, 6259, 6260, + 7, 6, 0, 0, 6260, 902, 1, 0, 0, 0, 6261, 6262, 7, 15, 0, 0, 6262, 6263, + 7, 12, 0, 0, 6263, 6264, 7, 14, 0, 0, 6264, 6265, 7, 8, 0, 0, 6265, 6266, + 7, 7, 0, 0, 6266, 6267, 7, 23, 0, 0, 6267, 6268, 7, 7, 0, 0, 6268, 6269, + 7, 12, 0, 0, 6269, 6270, 7, 6, 0, 0, 6270, 904, 1, 0, 0, 0, 6271, 6272, + 7, 15, 0, 0, 6272, 6273, 7, 12, 0, 0, 6273, 6274, 7, 4, 0, 0, 6274, 6275, + 7, 7, 0, 0, 6275, 6276, 7, 26, 0, 0, 6276, 6277, 7, 7, 0, 0, 6277, 6278, + 7, 11, 0, 0, 6278, 906, 1, 0, 0, 0, 6279, 6280, 7, 15, 0, 0, 6280, 6281, + 7, 12, 0, 0, 6281, 6282, 7, 15, 0, 0, 6282, 6283, 7, 6, 0, 0, 6283, 6284, + 7, 15, 0, 0, 6284, 6285, 7, 3, 0, 0, 6285, 6286, 7, 5, 0, 0, 6286, 6287, + 5, 95, 0, 0, 6287, 6288, 7, 11, 0, 0, 6288, 6289, 7, 15, 0, 0, 6289, 6290, + 7, 13, 0, 0, 6290, 6291, 7, 7, 0, 0, 6291, 908, 1, 0, 0, 0, 6292, 6293, + 7, 15, 0, 0, 6293, 6294, 7, 12, 0, 0, 6294, 6295, 7, 25, 0, 0, 6295, 6296, + 7, 5, 0, 0, 6296, 6297, 7, 3, 0, 0, 6297, 6298, 7, 14, 0, 0, 6298, 6299, + 7, 7, 0, 0, 6299, 910, 1, 0, 0, 0, 6300, 6301, 7, 15, 0, 0, 6301, 6302, + 7, 12, 0, 0, 6302, 6303, 7, 11, 0, 0, 6303, 6304, 7, 7, 0, 0, 6304, 6305, + 7, 8, 0, 0, 6305, 6306, 7, 6, 0, 0, 6306, 6307, 5, 95, 0, 0, 6307, 6308, + 7, 23, 0, 0, 6308, 6309, 7, 7, 0, 0, 6309, 6310, 7, 6, 0, 0, 6310, 6311, + 7, 20, 0, 0, 6311, 6312, 7, 19, 0, 0, 6312, 6313, 7, 4, 0, 0, 6313, 912, + 1, 0, 0, 0, 6314, 6315, 7, 15, 0, 0, 6315, 6316, 7, 12, 0, 0, 6316, 6317, + 7, 11, 0, 0, 6317, 6318, 7, 6, 0, 0, 6318, 6319, 7, 3, 0, 0, 6319, 6320, + 7, 5, 0, 0, 6320, 6321, 7, 5, 0, 0, 6321, 914, 1, 0, 0, 0, 6322, 6323, + 7, 15, 0, 0, 6323, 6324, 7, 12, 0, 0, 6324, 6325, 7, 11, 0, 0, 6325, 6326, + 7, 6, 0, 0, 6326, 6327, 7, 3, 0, 0, 6327, 6328, 7, 12, 0, 0, 6328, 6329, + 7, 14, 0, 0, 6329, 6330, 7, 7, 0, 0, 6330, 916, 1, 0, 0, 0, 6331, 6332, + 7, 15, 0, 0, 6332, 6333, 7, 12, 0, 0, 6333, 6334, 7, 11, 0, 0, 6334, 6335, + 7, 6, 0, 0, 6335, 6336, 7, 3, 0, 0, 6336, 6337, 7, 12, 0, 0, 6337, 6338, + 7, 6, 0, 0, 6338, 918, 1, 0, 0, 0, 6339, 6340, 7, 15, 0, 0, 6340, 6341, + 7, 12, 0, 0, 6341, 6342, 7, 24, 0, 0, 6342, 6343, 7, 15, 0, 0, 6343, 6344, + 7, 11, 0, 0, 6344, 6345, 7, 15, 0, 0, 6345, 6346, 7, 16, 0, 0, 6346, 6347, + 7, 5, 0, 0, 6347, 6348, 7, 7, 0, 0, 6348, 920, 1, 0, 0, 0, 6349, 6350, + 7, 15, 0, 0, 6350, 6351, 7, 12, 0, 0, 6351, 6352, 7, 24, 0, 0, 6352, 6353, + 7, 19, 0, 0, 6353, 6354, 7, 21, 0, 0, 6354, 6355, 7, 7, 0, 0, 6355, 6356, + 7, 8, 0, 0, 6356, 922, 1, 0, 0, 0, 6357, 6358, 7, 15, 0, 0, 6358, 6359, + 7, 19, 0, 0, 6359, 924, 1, 0, 0, 0, 6360, 6361, 7, 15, 0, 0, 6361, 6362, + 7, 19, 0, 0, 6362, 6363, 5, 95, 0, 0, 6363, 6364, 7, 6, 0, 0, 6364, 6365, + 7, 20, 0, 0, 6365, 6366, 7, 8, 0, 0, 6366, 6367, 7, 7, 0, 0, 6367, 6368, + 7, 3, 0, 0, 6368, 6369, 7, 4, 0, 0, 6369, 926, 1, 0, 0, 0, 6370, 6371, + 7, 15, 0, 0, 6371, 6372, 7, 25, 0, 0, 6372, 6373, 7, 14, 0, 0, 6373, 928, + 1, 0, 0, 0, 6374, 6375, 7, 15, 0, 0, 6375, 6376, 7, 11, 0, 0, 6376, 6377, + 7, 19, 0, 0, 6377, 6378, 7, 5, 0, 0, 6378, 6379, 7, 3, 0, 0, 6379, 6380, + 7, 6, 0, 0, 6380, 6381, 7, 15, 0, 0, 6381, 6382, 7, 19, 0, 0, 6382, 6383, + 7, 12, 0, 0, 6383, 930, 1, 0, 0, 0, 6384, 6385, 7, 15, 0, 0, 6385, 6386, + 7, 11, 0, 0, 6386, 6387, 7, 11, 0, 0, 6387, 6388, 7, 17, 0, 0, 6388, 6389, + 7, 7, 0, 0, 6389, 6390, 7, 8, 0, 0, 6390, 932, 1, 0, 0, 0, 6391, 6392, + 7, 27, 0, 0, 6392, 6393, 7, 11, 0, 0, 6393, 6394, 7, 19, 0, 0, 6394, 6395, + 7, 12, 0, 0, 6395, 934, 1, 0, 0, 0, 6396, 6397, 7, 21, 0, 0, 6397, 6398, + 7, 7, 0, 0, 6398, 6399, 7, 10, 0, 0, 6399, 6400, 5, 95, 0, 0, 6400, 6401, + 7, 16, 0, 0, 6401, 6402, 7, 5, 0, 0, 6402, 6403, 7, 19, 0, 0, 6403, 6404, + 7, 14, 0, 0, 6404, 6405, 7, 21, 0, 0, 6405, 6406, 5, 95, 0, 0, 6406, 6407, + 7, 11, 0, 0, 6407, 6408, 7, 15, 0, 0, 6408, 6409, 7, 13, 0, 0, 6409, 6410, + 7, 7, 0, 0, 6410, 936, 1, 0, 0, 0, 6411, 6412, 7, 5, 0, 0, 6412, 6413, + 7, 3, 0, 0, 6413, 6414, 7, 12, 0, 0, 6414, 6415, 7, 22, 0, 0, 6415, 6416, + 7, 17, 0, 0, 6416, 6417, 7, 3, 0, 0, 6417, 6418, 7, 22, 0, 0, 6418, 6419, + 7, 7, 0, 0, 6419, 938, 1, 0, 0, 0, 6420, 6421, 7, 5, 0, 0, 6421, 6422, + 7, 3, 0, 0, 6422, 6423, 7, 11, 0, 0, 6423, 6424, 7, 6, 0, 0, 6424, 940, + 1, 0, 0, 0, 6425, 6426, 7, 5, 0, 0, 6426, 6427, 7, 7, 0, 0, 6427, 6428, + 7, 3, 0, 0, 6428, 6429, 7, 24, 0, 0, 6429, 6430, 7, 7, 0, 0, 6430, 6431, + 7, 11, 0, 0, 6431, 942, 1, 0, 0, 0, 6432, 6433, 7, 5, 0, 0, 6433, 6434, + 7, 7, 0, 0, 6434, 6435, 7, 11, 0, 0, 6435, 6436, 7, 11, 0, 0, 6436, 944, + 1, 0, 0, 0, 6437, 6438, 7, 5, 0, 0, 6438, 6439, 7, 7, 0, 0, 6439, 6440, + 7, 24, 0, 0, 6440, 6441, 7, 7, 0, 0, 6441, 6442, 7, 5, 0, 0, 6442, 946, + 1, 0, 0, 0, 6443, 6444, 7, 5, 0, 0, 6444, 6445, 7, 15, 0, 0, 6445, 6446, + 7, 11, 0, 0, 6446, 6447, 7, 6, 0, 0, 6447, 948, 1, 0, 0, 0, 6448, 6449, + 7, 5, 0, 0, 6449, 6450, 7, 19, 0, 0, 6450, 6451, 7, 14, 0, 0, 6451, 6452, + 7, 3, 0, 0, 6452, 6453, 7, 5, 0, 0, 6453, 950, 1, 0, 0, 0, 6454, 6455, + 7, 5, 0, 0, 6455, 6456, 7, 19, 0, 0, 6456, 6457, 7, 22, 0, 0, 6457, 6458, + 7, 18, 0, 0, 6458, 6459, 7, 15, 0, 0, 6459, 6460, 7, 5, 0, 0, 6460, 6461, + 7, 7, 0, 0, 6461, 952, 1, 0, 0, 0, 6462, 6463, 7, 5, 0, 0, 6463, 6464, + 7, 19, 0, 0, 6464, 6465, 7, 22, 0, 0, 6465, 6466, 7, 11, 0, 0, 6466, 954, + 1, 0, 0, 0, 6467, 6468, 7, 23, 0, 0, 6468, 6469, 7, 3, 0, 0, 6469, 6470, + 7, 11, 0, 0, 6470, 6471, 7, 6, 0, 0, 6471, 6472, 7, 7, 0, 0, 6472, 6473, + 7, 8, 0, 0, 6473, 956, 1, 0, 0, 0, 6474, 6475, 7, 23, 0, 0, 6475, 6476, + 7, 3, 0, 0, 6476, 6477, 7, 11, 0, 0, 6477, 6478, 7, 6, 0, 0, 6478, 6479, + 7, 7, 0, 0, 6479, 6480, 7, 8, 0, 0, 6480, 6481, 5, 95, 0, 0, 6481, 6482, + 7, 3, 0, 0, 6482, 6483, 7, 17, 0, 0, 6483, 6484, 7, 6, 0, 0, 6484, 6485, + 7, 19, 0, 0, 6485, 6486, 5, 95, 0, 0, 6486, 6487, 7, 25, 0, 0, 6487, 6488, + 7, 19, 0, 0, 6488, 6489, 7, 11, 0, 0, 6489, 6490, 7, 15, 0, 0, 6490, 6491, + 7, 6, 0, 0, 6491, 6492, 7, 15, 0, 0, 6492, 6493, 7, 19, 0, 0, 6493, 6494, + 7, 12, 0, 0, 6494, 958, 1, 0, 0, 0, 6495, 6496, 7, 23, 0, 0, 6496, 6497, + 7, 3, 0, 0, 6497, 6498, 7, 11, 0, 0, 6498, 6499, 7, 6, 0, 0, 6499, 6500, + 7, 7, 0, 0, 6500, 6501, 7, 8, 0, 0, 6501, 6502, 5, 95, 0, 0, 6502, 6503, + 7, 14, 0, 0, 6503, 6504, 7, 19, 0, 0, 6504, 6505, 7, 12, 0, 0, 6505, 6506, + 7, 12, 0, 0, 6506, 6507, 7, 7, 0, 0, 6507, 6508, 7, 14, 0, 0, 6508, 6509, + 7, 6, 0, 0, 6509, 6510, 5, 95, 0, 0, 6510, 6511, 7, 8, 0, 0, 6511, 6512, + 7, 7, 0, 0, 6512, 6513, 7, 6, 0, 0, 6513, 6514, 7, 8, 0, 0, 6514, 6515, + 7, 10, 0, 0, 6515, 960, 1, 0, 0, 0, 6516, 6517, 7, 23, 0, 0, 6517, 6518, + 7, 3, 0, 0, 6518, 6519, 7, 11, 0, 0, 6519, 6520, 7, 6, 0, 0, 6520, 6521, + 7, 7, 0, 0, 6521, 6522, 7, 8, 0, 0, 6522, 6523, 5, 95, 0, 0, 6523, 6524, + 7, 4, 0, 0, 6524, 6525, 7, 7, 0, 0, 6525, 6526, 7, 5, 0, 0, 6526, 6527, + 7, 3, 0, 0, 6527, 6528, 7, 10, 0, 0, 6528, 962, 1, 0, 0, 0, 6529, 6530, + 7, 23, 0, 0, 6530, 6531, 7, 3, 0, 0, 6531, 6532, 7, 11, 0, 0, 6532, 6533, + 7, 6, 0, 0, 6533, 6534, 7, 7, 0, 0, 6534, 6535, 7, 8, 0, 0, 6535, 6536, + 5, 95, 0, 0, 6536, 6537, 7, 20, 0, 0, 6537, 6538, 7, 7, 0, 0, 6538, 6539, + 7, 3, 0, 0, 6539, 6540, 7, 8, 0, 0, 6540, 6541, 7, 6, 0, 0, 6541, 6542, + 7, 16, 0, 0, 6542, 6543, 7, 7, 0, 0, 6543, 6544, 7, 3, 0, 0, 6544, 6545, + 7, 6, 0, 0, 6545, 6546, 5, 95, 0, 0, 6546, 6547, 7, 25, 0, 0, 6547, 6548, + 7, 7, 0, 0, 6548, 6549, 7, 8, 0, 0, 6549, 6550, 7, 15, 0, 0, 6550, 6551, + 7, 19, 0, 0, 6551, 6552, 7, 4, 0, 0, 6552, 964, 1, 0, 0, 0, 6553, 6554, + 7, 23, 0, 0, 6554, 6555, 7, 3, 0, 0, 6555, 6556, 7, 11, 0, 0, 6556, 6557, + 7, 6, 0, 0, 6557, 6558, 7, 7, 0, 0, 6558, 6559, 7, 8, 0, 0, 6559, 6560, + 5, 95, 0, 0, 6560, 6561, 7, 20, 0, 0, 6561, 6562, 7, 19, 0, 0, 6562, 6563, + 7, 11, 0, 0, 6563, 6564, 7, 6, 0, 0, 6564, 966, 1, 0, 0, 0, 6565, 6566, + 7, 23, 0, 0, 6566, 6567, 7, 3, 0, 0, 6567, 6568, 7, 11, 0, 0, 6568, 6569, + 7, 6, 0, 0, 6569, 6570, 7, 7, 0, 0, 6570, 6571, 7, 8, 0, 0, 6571, 6572, + 5, 95, 0, 0, 6572, 6573, 7, 5, 0, 0, 6573, 6574, 7, 19, 0, 0, 6574, 6575, + 7, 22, 0, 0, 6575, 6576, 5, 95, 0, 0, 6576, 6577, 7, 18, 0, 0, 6577, 6578, + 7, 15, 0, 0, 6578, 6579, 7, 5, 0, 0, 6579, 6580, 7, 7, 0, 0, 6580, 968, + 1, 0, 0, 0, 6581, 6582, 7, 23, 0, 0, 6582, 6583, 7, 3, 0, 0, 6583, 6584, + 7, 11, 0, 0, 6584, 6585, 7, 6, 0, 0, 6585, 6586, 7, 7, 0, 0, 6586, 6587, + 7, 8, 0, 0, 6587, 6588, 5, 95, 0, 0, 6588, 6589, 7, 5, 0, 0, 6589, 6590, + 7, 19, 0, 0, 6590, 6591, 7, 22, 0, 0, 6591, 6592, 5, 95, 0, 0, 6592, 6593, + 7, 25, 0, 0, 6593, 6594, 7, 19, 0, 0, 6594, 6595, 7, 11, 0, 0, 6595, 970, + 1, 0, 0, 0, 6596, 6597, 7, 23, 0, 0, 6597, 6598, 7, 3, 0, 0, 6598, 6599, + 7, 11, 0, 0, 6599, 6600, 7, 6, 0, 0, 6600, 6601, 7, 7, 0, 0, 6601, 6602, + 7, 8, 0, 0, 6602, 6603, 5, 95, 0, 0, 6603, 6604, 7, 25, 0, 0, 6604, 6605, + 7, 3, 0, 0, 6605, 6606, 7, 11, 0, 0, 6606, 6607, 7, 11, 0, 0, 6607, 6608, + 7, 9, 0, 0, 6608, 6609, 7, 19, 0, 0, 6609, 6610, 7, 8, 0, 0, 6610, 6611, + 7, 4, 0, 0, 6611, 972, 1, 0, 0, 0, 6612, 6613, 7, 23, 0, 0, 6613, 6614, + 7, 3, 0, 0, 6614, 6615, 7, 11, 0, 0, 6615, 6616, 7, 6, 0, 0, 6616, 6617, + 7, 7, 0, 0, 6617, 6618, 7, 8, 0, 0, 6618, 6619, 5, 95, 0, 0, 6619, 6620, + 7, 25, 0, 0, 6620, 6621, 7, 19, 0, 0, 6621, 6622, 7, 8, 0, 0, 6622, 6623, + 7, 6, 0, 0, 6623, 974, 1, 0, 0, 0, 6624, 6625, 7, 23, 0, 0, 6625, 6626, + 7, 3, 0, 0, 6626, 6627, 7, 11, 0, 0, 6627, 6628, 7, 6, 0, 0, 6628, 6629, + 7, 7, 0, 0, 6629, 6630, 7, 8, 0, 0, 6630, 6631, 5, 95, 0, 0, 6631, 6632, + 7, 8, 0, 0, 6632, 6633, 7, 7, 0, 0, 6633, 6634, 7, 6, 0, 0, 6634, 6635, + 7, 8, 0, 0, 6635, 6636, 7, 10, 0, 0, 6636, 6637, 5, 95, 0, 0, 6637, 6638, + 7, 14, 0, 0, 6638, 6639, 7, 19, 0, 0, 6639, 6640, 7, 17, 0, 0, 6640, 6641, + 7, 12, 0, 0, 6641, 6642, 7, 6, 0, 0, 6642, 976, 1, 0, 0, 0, 6643, 6644, + 7, 23, 0, 0, 6644, 6645, 7, 3, 0, 0, 6645, 6646, 7, 11, 0, 0, 6646, 6647, + 7, 6, 0, 0, 6647, 6648, 7, 7, 0, 0, 6648, 6649, 7, 8, 0, 0, 6649, 6650, + 5, 95, 0, 0, 6650, 6651, 7, 11, 0, 0, 6651, 6652, 7, 11, 0, 0, 6652, 6653, + 7, 5, 0, 0, 6653, 978, 1, 0, 0, 0, 6654, 6655, 7, 23, 0, 0, 6655, 6656, + 7, 3, 0, 0, 6656, 6657, 7, 11, 0, 0, 6657, 6658, 7, 6, 0, 0, 6658, 6659, + 7, 7, 0, 0, 6659, 6660, 7, 8, 0, 0, 6660, 6661, 5, 95, 0, 0, 6661, 6662, + 7, 11, 0, 0, 6662, 6663, 7, 11, 0, 0, 6663, 6664, 7, 5, 0, 0, 6664, 6665, + 5, 95, 0, 0, 6665, 6666, 7, 14, 0, 0, 6666, 6667, 7, 3, 0, 0, 6667, 980, + 1, 0, 0, 0, 6668, 6669, 7, 23, 0, 0, 6669, 6670, 7, 3, 0, 0, 6670, 6671, + 7, 11, 0, 0, 6671, 6672, 7, 6, 0, 0, 6672, 6673, 7, 7, 0, 0, 6673, 6674, + 7, 8, 0, 0, 6674, 6675, 5, 95, 0, 0, 6675, 6676, 7, 11, 0, 0, 6676, 6677, + 7, 11, 0, 0, 6677, 6678, 7, 5, 0, 0, 6678, 6679, 5, 95, 0, 0, 6679, 6680, + 7, 14, 0, 0, 6680, 6681, 7, 3, 0, 0, 6681, 6682, 7, 25, 0, 0, 6682, 6683, + 7, 3, 0, 0, 6683, 6684, 7, 6, 0, 0, 6684, 6685, 7, 20, 0, 0, 6685, 982, + 1, 0, 0, 0, 6686, 6687, 7, 23, 0, 0, 6687, 6688, 7, 3, 0, 0, 6688, 6689, + 7, 11, 0, 0, 6689, 6690, 7, 6, 0, 0, 6690, 6691, 7, 7, 0, 0, 6691, 6692, + 7, 8, 0, 0, 6692, 6693, 5, 95, 0, 0, 6693, 6694, 7, 11, 0, 0, 6694, 6695, + 7, 11, 0, 0, 6695, 6696, 7, 5, 0, 0, 6696, 6697, 5, 95, 0, 0, 6697, 6698, + 7, 14, 0, 0, 6698, 6699, 7, 7, 0, 0, 6699, 6700, 7, 8, 0, 0, 6700, 6701, + 7, 6, 0, 0, 6701, 984, 1, 0, 0, 0, 6702, 6703, 7, 23, 0, 0, 6703, 6704, + 7, 3, 0, 0, 6704, 6705, 7, 11, 0, 0, 6705, 6706, 7, 6, 0, 0, 6706, 6707, + 7, 7, 0, 0, 6707, 6708, 7, 8, 0, 0, 6708, 6709, 5, 95, 0, 0, 6709, 6710, + 7, 11, 0, 0, 6710, 6711, 7, 11, 0, 0, 6711, 6712, 7, 5, 0, 0, 6712, 6713, + 5, 95, 0, 0, 6713, 6714, 7, 14, 0, 0, 6714, 6715, 7, 15, 0, 0, 6715, 6716, + 7, 25, 0, 0, 6716, 6717, 7, 20, 0, 0, 6717, 6718, 7, 7, 0, 0, 6718, 6719, + 7, 8, 0, 0, 6719, 986, 1, 0, 0, 0, 6720, 6721, 7, 23, 0, 0, 6721, 6722, + 7, 3, 0, 0, 6722, 6723, 7, 11, 0, 0, 6723, 6724, 7, 6, 0, 0, 6724, 6725, + 7, 7, 0, 0, 6725, 6726, 7, 8, 0, 0, 6726, 6727, 5, 95, 0, 0, 6727, 6728, + 7, 11, 0, 0, 6728, 6729, 7, 11, 0, 0, 6729, 6730, 7, 5, 0, 0, 6730, 6731, + 5, 95, 0, 0, 6731, 6732, 7, 14, 0, 0, 6732, 6733, 7, 8, 0, 0, 6733, 6734, + 7, 5, 0, 0, 6734, 988, 1, 0, 0, 0, 6735, 6736, 7, 23, 0, 0, 6736, 6737, + 7, 3, 0, 0, 6737, 6738, 7, 11, 0, 0, 6738, 6739, 7, 6, 0, 0, 6739, 6740, + 7, 7, 0, 0, 6740, 6741, 7, 8, 0, 0, 6741, 6742, 5, 95, 0, 0, 6742, 6743, + 7, 11, 0, 0, 6743, 6744, 7, 11, 0, 0, 6744, 6745, 7, 5, 0, 0, 6745, 6746, + 5, 95, 0, 0, 6746, 6747, 7, 14, 0, 0, 6747, 6748, 7, 8, 0, 0, 6748, 6749, + 7, 5, 0, 0, 6749, 6750, 7, 25, 0, 0, 6750, 6751, 7, 3, 0, 0, 6751, 6752, + 7, 6, 0, 0, 6752, 6753, 7, 20, 0, 0, 6753, 990, 1, 0, 0, 0, 6754, 6755, + 7, 23, 0, 0, 6755, 6756, 7, 3, 0, 0, 6756, 6757, 7, 11, 0, 0, 6757, 6758, + 7, 6, 0, 0, 6758, 6759, 7, 7, 0, 0, 6759, 6760, 7, 8, 0, 0, 6760, 6761, + 5, 95, 0, 0, 6761, 6762, 7, 11, 0, 0, 6762, 6763, 7, 11, 0, 0, 6763, 6764, + 7, 5, 0, 0, 6764, 6765, 5, 95, 0, 0, 6765, 6766, 7, 21, 0, 0, 6766, 6767, + 7, 7, 0, 0, 6767, 6768, 7, 10, 0, 0, 6768, 992, 1, 0, 0, 0, 6769, 6770, + 7, 23, 0, 0, 6770, 6771, 7, 3, 0, 0, 6771, 6772, 7, 11, 0, 0, 6772, 6773, + 7, 6, 0, 0, 6773, 6774, 7, 7, 0, 0, 6774, 6775, 7, 8, 0, 0, 6775, 6776, + 5, 95, 0, 0, 6776, 6777, 7, 6, 0, 0, 6777, 6778, 7, 5, 0, 0, 6778, 6779, + 7, 11, 0, 0, 6779, 6780, 5, 95, 0, 0, 6780, 6781, 7, 24, 0, 0, 6781, 6782, + 7, 7, 0, 0, 6782, 6783, 7, 8, 0, 0, 6783, 6784, 7, 11, 0, 0, 6784, 6785, + 7, 15, 0, 0, 6785, 6786, 7, 19, 0, 0, 6786, 6787, 7, 12, 0, 0, 6787, 994, + 1, 0, 0, 0, 6788, 6789, 7, 23, 0, 0, 6789, 6790, 7, 3, 0, 0, 6790, 6791, + 7, 11, 0, 0, 6791, 6792, 7, 6, 0, 0, 6792, 6793, 7, 7, 0, 0, 6793, 6794, + 7, 8, 0, 0, 6794, 6795, 5, 95, 0, 0, 6795, 6796, 7, 17, 0, 0, 6796, 6797, + 7, 11, 0, 0, 6797, 6798, 7, 7, 0, 0, 6798, 6799, 7, 8, 0, 0, 6799, 996, + 1, 0, 0, 0, 6800, 6801, 7, 23, 0, 0, 6801, 6802, 7, 3, 0, 0, 6802, 6803, + 7, 26, 0, 0, 6803, 6804, 5, 95, 0, 0, 6804, 6805, 7, 14, 0, 0, 6805, 6806, + 7, 19, 0, 0, 6806, 6807, 7, 12, 0, 0, 6807, 6808, 7, 12, 0, 0, 6808, 6809, + 7, 7, 0, 0, 6809, 6810, 7, 14, 0, 0, 6810, 6811, 7, 6, 0, 0, 6811, 6812, + 7, 15, 0, 0, 6812, 6813, 7, 19, 0, 0, 6813, 6814, 7, 12, 0, 0, 6814, 6815, + 7, 11, 0, 0, 6815, 6816, 5, 95, 0, 0, 6816, 6817, 7, 25, 0, 0, 6817, 6818, + 7, 7, 0, 0, 6818, 6819, 7, 8, 0, 0, 6819, 6820, 5, 95, 0, 0, 6820, 6821, + 7, 20, 0, 0, 6821, 6822, 7, 19, 0, 0, 6822, 6823, 7, 17, 0, 0, 6823, 6824, + 7, 8, 0, 0, 6824, 998, 1, 0, 0, 0, 6825, 6826, 7, 23, 0, 0, 6826, 6827, + 7, 3, 0, 0, 6827, 6828, 7, 26, 0, 0, 6828, 6829, 5, 95, 0, 0, 6829, 6830, + 7, 28, 0, 0, 6830, 6831, 7, 17, 0, 0, 6831, 6832, 7, 7, 0, 0, 6832, 6833, + 7, 8, 0, 0, 6833, 6834, 7, 15, 0, 0, 6834, 6835, 7, 7, 0, 0, 6835, 6836, + 7, 11, 0, 0, 6836, 6837, 5, 95, 0, 0, 6837, 6838, 7, 25, 0, 0, 6838, 6839, + 7, 7, 0, 0, 6839, 6840, 7, 8, 0, 0, 6840, 6841, 5, 95, 0, 0, 6841, 6842, + 7, 20, 0, 0, 6842, 6843, 7, 19, 0, 0, 6843, 6844, 7, 17, 0, 0, 6844, 6845, + 7, 8, 0, 0, 6845, 1000, 1, 0, 0, 0, 6846, 6847, 7, 23, 0, 0, 6847, 6848, + 7, 3, 0, 0, 6848, 6849, 7, 26, 0, 0, 6849, 6850, 5, 95, 0, 0, 6850, 6851, + 7, 8, 0, 0, 6851, 6852, 7, 19, 0, 0, 6852, 6853, 7, 9, 0, 0, 6853, 6854, + 7, 11, 0, 0, 6854, 1002, 1, 0, 0, 0, 6855, 6856, 7, 23, 0, 0, 6856, 6857, + 7, 3, 0, 0, 6857, 6858, 7, 26, 0, 0, 6858, 6859, 5, 95, 0, 0, 6859, 6860, + 7, 11, 0, 0, 6860, 6861, 7, 15, 0, 0, 6861, 6862, 7, 13, 0, 0, 6862, 6863, + 7, 7, 0, 0, 6863, 1004, 1, 0, 0, 0, 6864, 6865, 7, 23, 0, 0, 6865, 6866, + 7, 3, 0, 0, 6866, 6867, 7, 26, 0, 0, 6867, 6868, 5, 95, 0, 0, 6868, 6869, + 7, 17, 0, 0, 6869, 6870, 7, 25, 0, 0, 6870, 6871, 7, 4, 0, 0, 6871, 6872, + 7, 3, 0, 0, 6872, 6873, 7, 6, 0, 0, 6873, 6874, 7, 7, 0, 0, 6874, 6875, + 7, 11, 0, 0, 6875, 6876, 5, 95, 0, 0, 6876, 6877, 7, 25, 0, 0, 6877, 6878, + 7, 7, 0, 0, 6878, 6879, 7, 8, 0, 0, 6879, 6880, 5, 95, 0, 0, 6880, 6881, + 7, 20, 0, 0, 6881, 6882, 7, 19, 0, 0, 6882, 6883, 7, 17, 0, 0, 6883, 6884, + 7, 8, 0, 0, 6884, 1006, 1, 0, 0, 0, 6885, 6886, 7, 23, 0, 0, 6886, 6887, + 7, 3, 0, 0, 6887, 6888, 7, 26, 0, 0, 6888, 6889, 5, 95, 0, 0, 6889, 6890, + 7, 17, 0, 0, 6890, 6891, 7, 11, 0, 0, 6891, 6892, 7, 7, 0, 0, 6892, 6893, + 7, 8, 0, 0, 6893, 6894, 5, 95, 0, 0, 6894, 6895, 7, 14, 0, 0, 6895, 6896, + 7, 19, 0, 0, 6896, 6897, 7, 12, 0, 0, 6897, 6898, 7, 12, 0, 0, 6898, 6899, + 7, 7, 0, 0, 6899, 6900, 7, 14, 0, 0, 6900, 6901, 7, 6, 0, 0, 6901, 6902, + 7, 15, 0, 0, 6902, 6903, 7, 19, 0, 0, 6903, 6904, 7, 12, 0, 0, 6904, 6905, + 7, 11, 0, 0, 6905, 1008, 1, 0, 0, 0, 6906, 6907, 7, 23, 0, 0, 6907, 6908, + 7, 7, 0, 0, 6908, 6909, 7, 4, 0, 0, 6909, 6910, 7, 15, 0, 0, 6910, 6911, + 7, 17, 0, 0, 6911, 6912, 7, 23, 0, 0, 6912, 1010, 1, 0, 0, 0, 6913, 6914, + 7, 23, 0, 0, 6914, 6915, 7, 7, 0, 0, 6915, 6916, 7, 23, 0, 0, 6916, 6917, + 7, 16, 0, 0, 6917, 6918, 7, 7, 0, 0, 6918, 6919, 7, 8, 0, 0, 6919, 1012, + 1, 0, 0, 0, 6920, 6921, 7, 23, 0, 0, 6921, 6922, 7, 7, 0, 0, 6922, 6923, + 7, 8, 0, 0, 6923, 6924, 7, 22, 0, 0, 6924, 6925, 7, 7, 0, 0, 6925, 1014, + 1, 0, 0, 0, 6926, 6927, 7, 23, 0, 0, 6927, 6928, 7, 7, 0, 0, 6928, 6929, + 7, 11, 0, 0, 6929, 6930, 7, 11, 0, 0, 6930, 6931, 7, 3, 0, 0, 6931, 6932, + 7, 22, 0, 0, 6932, 6933, 7, 7, 0, 0, 6933, 6934, 5, 95, 0, 0, 6934, 6935, + 7, 6, 0, 0, 6935, 6936, 7, 7, 0, 0, 6936, 6937, 7, 26, 0, 0, 6937, 6938, + 7, 6, 0, 0, 6938, 1016, 1, 0, 0, 0, 6939, 6940, 7, 23, 0, 0, 6940, 6941, + 7, 15, 0, 0, 6941, 6942, 7, 4, 0, 0, 6942, 1018, 1, 0, 0, 0, 6943, 6944, + 7, 23, 0, 0, 6944, 6945, 7, 15, 0, 0, 6945, 6946, 7, 22, 0, 0, 6946, 6947, + 7, 8, 0, 0, 6947, 6948, 7, 3, 0, 0, 6948, 6949, 7, 6, 0, 0, 6949, 6950, + 7, 7, 0, 0, 6950, 1020, 1, 0, 0, 0, 6951, 6952, 7, 23, 0, 0, 6952, 6953, + 7, 15, 0, 0, 6953, 6954, 7, 12, 0, 0, 6954, 6955, 5, 95, 0, 0, 6955, 6956, + 7, 8, 0, 0, 6956, 6957, 7, 19, 0, 0, 6957, 6958, 7, 9, 0, 0, 6958, 6959, + 7, 11, 0, 0, 6959, 1022, 1, 0, 0, 0, 6960, 6961, 7, 23, 0, 0, 6961, 6962, + 7, 19, 0, 0, 6962, 6963, 7, 4, 0, 0, 6963, 6964, 7, 7, 0, 0, 6964, 1024, + 1, 0, 0, 0, 6965, 6966, 7, 23, 0, 0, 6966, 6967, 7, 19, 0, 0, 6967, 6968, + 7, 4, 0, 0, 6968, 6969, 7, 15, 0, 0, 6969, 6970, 7, 18, 0, 0, 6970, 6971, + 7, 10, 0, 0, 6971, 1026, 1, 0, 0, 0, 6972, 6973, 7, 23, 0, 0, 6973, 6974, + 7, 17, 0, 0, 6974, 6975, 7, 6, 0, 0, 6975, 6976, 7, 7, 0, 0, 6976, 6977, + 7, 26, 0, 0, 6977, 1028, 1, 0, 0, 0, 6978, 6979, 7, 23, 0, 0, 6979, 6980, + 7, 10, 0, 0, 6980, 6981, 7, 11, 0, 0, 6981, 6982, 7, 28, 0, 0, 6982, 6983, + 7, 5, 0, 0, 6983, 1030, 1, 0, 0, 0, 6984, 6985, 7, 23, 0, 0, 6985, 6986, + 7, 10, 0, 0, 6986, 6987, 7, 11, 0, 0, 6987, 6988, 7, 28, 0, 0, 6988, 6989, + 7, 5, 0, 0, 6989, 6990, 5, 95, 0, 0, 6990, 6991, 7, 7, 0, 0, 6991, 6992, + 7, 8, 0, 0, 6992, 6993, 7, 8, 0, 0, 6993, 6994, 7, 12, 0, 0, 6994, 6995, + 7, 19, 0, 0, 6995, 1032, 1, 0, 0, 0, 6996, 6997, 7, 12, 0, 0, 6997, 6998, + 7, 3, 0, 0, 6998, 6999, 7, 23, 0, 0, 6999, 7000, 7, 7, 0, 0, 7000, 1034, + 1, 0, 0, 0, 7001, 7002, 7, 12, 0, 0, 7002, 7003, 7, 3, 0, 0, 7003, 7004, + 7, 23, 0, 0, 7004, 7005, 7, 7, 0, 0, 7005, 7006, 7, 11, 0, 0, 7006, 1036, + 1, 0, 0, 0, 7007, 7008, 7, 12, 0, 0, 7008, 7009, 7, 14, 0, 0, 7009, 7010, + 7, 20, 0, 0, 7010, 7011, 7, 3, 0, 0, 7011, 7012, 7, 8, 0, 0, 7012, 1038, + 1, 0, 0, 0, 7013, 7014, 7, 12, 0, 0, 7014, 7015, 7, 7, 0, 0, 7015, 7016, + 7, 24, 0, 0, 7016, 7017, 7, 7, 0, 0, 7017, 7018, 7, 8, 0, 0, 7018, 1040, + 1, 0, 0, 0, 7019, 7020, 7, 12, 0, 0, 7020, 7021, 7, 7, 0, 0, 7021, 7022, + 7, 26, 0, 0, 7022, 7023, 7, 6, 0, 0, 7023, 1042, 1, 0, 0, 0, 7024, 7025, + 7, 12, 0, 0, 7025, 7026, 7, 19, 0, 0, 7026, 1044, 1, 0, 0, 0, 7027, 7028, + 7, 12, 0, 0, 7028, 7029, 7, 19, 0, 0, 7029, 7030, 7, 14, 0, 0, 7030, 7031, + 7, 3, 0, 0, 7031, 7032, 7, 14, 0, 0, 7032, 7033, 7, 20, 0, 0, 7033, 7034, + 7, 7, 0, 0, 7034, 1046, 1, 0, 0, 0, 7035, 7036, 7, 12, 0, 0, 7036, 7037, + 7, 19, 0, 0, 7037, 7038, 7, 14, 0, 0, 7038, 7039, 7, 19, 0, 0, 7039, 7040, + 7, 25, 0, 0, 7040, 7041, 7, 10, 0, 0, 7041, 1048, 1, 0, 0, 0, 7042, 7043, + 7, 12, 0, 0, 7043, 7044, 7, 19, 0, 0, 7044, 7045, 7, 14, 0, 0, 7045, 7046, + 7, 10, 0, 0, 7046, 7047, 7, 14, 0, 0, 7047, 7048, 7, 5, 0, 0, 7048, 7049, + 7, 7, 0, 0, 7049, 1050, 1, 0, 0, 0, 7050, 7051, 7, 12, 0, 0, 7051, 7052, + 7, 19, 0, 0, 7052, 7053, 7, 23, 0, 0, 7053, 7054, 7, 3, 0, 0, 7054, 7055, + 7, 26, 0, 0, 7055, 7056, 7, 24, 0, 0, 7056, 7057, 7, 3, 0, 0, 7057, 7058, + 7, 5, 0, 0, 7058, 7059, 7, 17, 0, 0, 7059, 7060, 7, 7, 0, 0, 7060, 1052, + 1, 0, 0, 0, 7061, 7062, 7, 12, 0, 0, 7062, 7063, 7, 19, 0, 0, 7063, 7064, + 7, 23, 0, 0, 7064, 7065, 7, 15, 0, 0, 7065, 7066, 7, 12, 0, 0, 7066, 7067, + 7, 24, 0, 0, 7067, 7068, 7, 3, 0, 0, 7068, 7069, 7, 5, 0, 0, 7069, 7070, + 7, 17, 0, 0, 7070, 7071, 7, 7, 0, 0, 7071, 1054, 1, 0, 0, 0, 7072, 7073, + 7, 12, 0, 0, 7073, 7074, 7, 19, 0, 0, 7074, 7075, 7, 9, 0, 0, 7075, 7076, + 7, 3, 0, 0, 7076, 7077, 7, 15, 0, 0, 7077, 7078, 7, 6, 0, 0, 7078, 1056, + 1, 0, 0, 0, 7079, 7080, 7, 12, 0, 0, 7080, 7081, 7, 19, 0, 0, 7081, 7082, + 7, 4, 0, 0, 7082, 7083, 7, 7, 0, 0, 7083, 7084, 7, 22, 0, 0, 7084, 7085, + 7, 8, 0, 0, 7085, 7086, 7, 19, 0, 0, 7086, 7087, 7, 17, 0, 0, 7087, 7088, + 7, 25, 0, 0, 7088, 1058, 1, 0, 0, 0, 7089, 7090, 7, 12, 0, 0, 7090, 7091, + 7, 19, 0, 0, 7091, 7092, 7, 12, 0, 0, 7092, 7093, 7, 7, 0, 0, 7093, 1060, + 1, 0, 0, 0, 7094, 7095, 7, 19, 0, 0, 7095, 7096, 7, 4, 0, 0, 7096, 7097, + 7, 16, 0, 0, 7097, 7098, 7, 14, 0, 0, 7098, 1062, 1, 0, 0, 0, 7099, 7100, + 7, 19, 0, 0, 7100, 7101, 7, 18, 0, 0, 7101, 7102, 7, 18, 0, 0, 7102, 7103, + 7, 5, 0, 0, 7103, 7104, 7, 15, 0, 0, 7104, 7105, 7, 12, 0, 0, 7105, 7106, + 7, 7, 0, 0, 7106, 1064, 1, 0, 0, 0, 7107, 7108, 7, 19, 0, 0, 7108, 7109, + 7, 18, 0, 0, 7109, 7110, 7, 18, 0, 0, 7110, 7111, 7, 11, 0, 0, 7111, 7112, + 7, 7, 0, 0, 7112, 7113, 7, 6, 0, 0, 7113, 1066, 1, 0, 0, 0, 7114, 7115, + 7, 19, 0, 0, 7115, 7116, 7, 18, 0, 0, 7116, 1068, 1, 0, 0, 0, 7117, 7118, + 7, 19, 0, 0, 7118, 7119, 7, 27, 0, 0, 7119, 1070, 1, 0, 0, 0, 7120, 7121, + 7, 19, 0, 0, 7121, 7122, 7, 5, 0, 0, 7122, 7123, 7, 4, 0, 0, 7123, 7124, + 5, 95, 0, 0, 7124, 7125, 7, 25, 0, 0, 7125, 7126, 7, 3, 0, 0, 7126, 7127, + 7, 11, 0, 0, 7127, 7128, 7, 11, 0, 0, 7128, 7129, 7, 9, 0, 0, 7129, 7130, + 7, 19, 0, 0, 7130, 7131, 7, 8, 0, 0, 7131, 7132, 7, 4, 0, 0, 7132, 1072, + 1, 0, 0, 0, 7133, 7134, 7, 19, 0, 0, 7134, 7135, 7, 12, 0, 0, 7135, 7136, + 7, 7, 0, 0, 7136, 1074, 1, 0, 0, 0, 7137, 7138, 7, 19, 0, 0, 7138, 7139, + 7, 12, 0, 0, 7139, 7140, 7, 5, 0, 0, 7140, 7141, 7, 15, 0, 0, 7141, 7142, + 7, 12, 0, 0, 7142, 7143, 7, 7, 0, 0, 7143, 1076, 1, 0, 0, 0, 7144, 7145, + 7, 19, 0, 0, 7145, 7146, 7, 12, 0, 0, 7146, 7147, 7, 5, 0, 0, 7147, 7148, + 7, 10, 0, 0, 7148, 1078, 1, 0, 0, 0, 7149, 7150, 7, 19, 0, 0, 7150, 7151, + 7, 25, 0, 0, 7151, 7152, 7, 7, 0, 0, 7152, 7153, 7, 12, 0, 0, 7153, 1080, + 1, 0, 0, 0, 7154, 7155, 7, 19, 0, 0, 7155, 7156, 7, 25, 0, 0, 7156, 7157, + 7, 6, 0, 0, 7157, 7158, 7, 15, 0, 0, 7158, 7159, 7, 23, 0, 0, 7159, 7160, + 7, 15, 0, 0, 7160, 7161, 7, 13, 0, 0, 7161, 7162, 7, 7, 0, 0, 7162, 7163, + 7, 8, 0, 0, 7163, 7164, 5, 95, 0, 0, 7164, 7165, 7, 14, 0, 0, 7165, 7166, + 7, 19, 0, 0, 7166, 7167, 7, 11, 0, 0, 7167, 7168, 7, 6, 0, 0, 7168, 7169, + 7, 11, 0, 0, 7169, 1082, 1, 0, 0, 0, 7170, 7171, 7, 19, 0, 0, 7171, 7172, + 7, 25, 0, 0, 7172, 7173, 7, 6, 0, 0, 7173, 7174, 7, 15, 0, 0, 7174, 7175, + 7, 19, 0, 0, 7175, 7176, 7, 12, 0, 0, 7176, 7177, 7, 11, 0, 0, 7177, 1084, + 1, 0, 0, 0, 7178, 7179, 7, 19, 0, 0, 7179, 7180, 7, 9, 0, 0, 7180, 7181, + 7, 12, 0, 0, 7181, 7182, 7, 7, 0, 0, 7182, 7183, 7, 8, 0, 0, 7183, 1086, + 1, 0, 0, 0, 7184, 7185, 7, 25, 0, 0, 7185, 7186, 7, 3, 0, 0, 7186, 7187, + 7, 14, 0, 0, 7187, 7188, 7, 21, 0, 0, 7188, 7189, 5, 95, 0, 0, 7189, 7190, + 7, 21, 0, 0, 7190, 7191, 7, 7, 0, 0, 7191, 7192, 7, 10, 0, 0, 7192, 7193, + 7, 11, 0, 0, 7193, 1088, 1, 0, 0, 0, 7194, 7195, 7, 25, 0, 0, 7195, 7196, + 7, 3, 0, 0, 7196, 7197, 7, 22, 0, 0, 7197, 7198, 7, 7, 0, 0, 7198, 1090, + 1, 0, 0, 0, 7199, 7200, 7, 25, 0, 0, 7200, 7201, 7, 3, 0, 0, 7201, 7202, + 7, 22, 0, 0, 7202, 7203, 7, 7, 0, 0, 7203, 7204, 5, 95, 0, 0, 7204, 7205, + 7, 14, 0, 0, 7205, 7206, 7, 19, 0, 0, 7206, 7207, 7, 23, 0, 0, 7207, 7208, + 7, 25, 0, 0, 7208, 7209, 7, 8, 0, 0, 7209, 7210, 7, 7, 0, 0, 7210, 7211, + 7, 11, 0, 0, 7211, 7212, 7, 11, 0, 0, 7212, 7213, 7, 7, 0, 0, 7213, 7214, + 7, 4, 0, 0, 7214, 1092, 1, 0, 0, 0, 7215, 7216, 7, 25, 0, 0, 7216, 7217, + 7, 3, 0, 0, 7217, 7218, 7, 22, 0, 0, 7218, 7219, 7, 7, 0, 0, 7219, 7220, + 5, 95, 0, 0, 7220, 7221, 7, 14, 0, 0, 7221, 7222, 7, 19, 0, 0, 7222, 7223, + 7, 23, 0, 0, 7223, 7224, 7, 25, 0, 0, 7224, 7225, 7, 8, 0, 0, 7225, 7226, + 7, 7, 0, 0, 7226, 7227, 7, 11, 0, 0, 7227, 7228, 7, 11, 0, 0, 7228, 7229, + 7, 15, 0, 0, 7229, 7230, 7, 19, 0, 0, 7230, 7231, 7, 12, 0, 0, 7231, 7232, + 5, 95, 0, 0, 7232, 7233, 7, 5, 0, 0, 7233, 7234, 7, 7, 0, 0, 7234, 7235, + 7, 24, 0, 0, 7235, 7236, 7, 7, 0, 0, 7236, 7237, 7, 5, 0, 0, 7237, 1094, + 1, 0, 0, 0, 7238, 7239, 7, 25, 0, 0, 7239, 7240, 7, 3, 0, 0, 7240, 7241, + 7, 8, 0, 0, 7241, 7242, 7, 11, 0, 0, 7242, 7243, 7, 7, 0, 0, 7243, 7244, + 7, 8, 0, 0, 7244, 1096, 1, 0, 0, 0, 7245, 7246, 7, 25, 0, 0, 7246, 7247, + 7, 3, 0, 0, 7247, 7248, 7, 8, 0, 0, 7248, 7249, 7, 6, 0, 0, 7249, 7250, + 7, 15, 0, 0, 7250, 7251, 7, 3, 0, 0, 7251, 7252, 7, 5, 0, 0, 7252, 1098, + 1, 0, 0, 0, 7253, 7254, 7, 25, 0, 0, 7254, 7255, 7, 3, 0, 0, 7255, 7256, + 7, 8, 0, 0, 7256, 7257, 7, 6, 0, 0, 7257, 7258, 7, 15, 0, 0, 7258, 7259, + 7, 6, 0, 0, 7259, 7260, 7, 15, 0, 0, 7260, 7261, 7, 19, 0, 0, 7261, 7262, + 7, 12, 0, 0, 7262, 7263, 7, 15, 0, 0, 7263, 7264, 7, 12, 0, 0, 7264, 7265, + 7, 22, 0, 0, 7265, 1100, 1, 0, 0, 0, 7266, 7267, 7, 25, 0, 0, 7267, 7268, + 7, 3, 0, 0, 7268, 7269, 7, 8, 0, 0, 7269, 7270, 7, 6, 0, 0, 7270, 7271, + 7, 15, 0, 0, 7271, 7272, 7, 6, 0, 0, 7272, 7273, 7, 15, 0, 0, 7273, 7274, + 7, 19, 0, 0, 7274, 7275, 7, 12, 0, 0, 7275, 7276, 7, 11, 0, 0, 7276, 1102, + 1, 0, 0, 0, 7277, 7278, 7, 25, 0, 0, 7278, 7279, 7, 3, 0, 0, 7279, 7280, + 7, 11, 0, 0, 7280, 7281, 7, 11, 0, 0, 7281, 7282, 7, 9, 0, 0, 7282, 7283, + 7, 19, 0, 0, 7283, 7284, 7, 8, 0, 0, 7284, 7285, 7, 4, 0, 0, 7285, 1104, + 1, 0, 0, 0, 7286, 7287, 7, 25, 0, 0, 7287, 7288, 7, 3, 0, 0, 7288, 7289, + 7, 11, 0, 0, 7289, 7290, 7, 11, 0, 0, 7290, 7291, 7, 9, 0, 0, 7291, 7292, + 7, 19, 0, 0, 7292, 7293, 7, 8, 0, 0, 7293, 7294, 7, 4, 0, 0, 7294, 7295, + 5, 95, 0, 0, 7295, 7296, 7, 5, 0, 0, 7296, 7297, 7, 19, 0, 0, 7297, 7298, + 7, 14, 0, 0, 7298, 7299, 7, 21, 0, 0, 7299, 7300, 5, 95, 0, 0, 7300, 7301, + 7, 6, 0, 0, 7301, 7302, 7, 15, 0, 0, 7302, 7303, 7, 23, 0, 0, 7303, 7304, + 7, 7, 0, 0, 7304, 1106, 1, 0, 0, 0, 7305, 7306, 7, 25, 0, 0, 7306, 7307, + 7, 20, 0, 0, 7307, 7308, 7, 3, 0, 0, 7308, 7309, 7, 11, 0, 0, 7309, 7310, + 7, 7, 0, 0, 7310, 1108, 1, 0, 0, 0, 7311, 7312, 7, 25, 0, 0, 7312, 7313, + 7, 5, 0, 0, 7313, 7314, 7, 17, 0, 0, 7314, 7315, 7, 22, 0, 0, 7315, 7316, + 7, 15, 0, 0, 7316, 7317, 7, 12, 0, 0, 7317, 1110, 1, 0, 0, 0, 7318, 7319, + 7, 25, 0, 0, 7319, 7320, 7, 5, 0, 0, 7320, 7321, 7, 17, 0, 0, 7321, 7322, + 7, 22, 0, 0, 7322, 7323, 7, 15, 0, 0, 7323, 7324, 7, 12, 0, 0, 7324, 7325, + 5, 95, 0, 0, 7325, 7326, 7, 4, 0, 0, 7326, 7327, 7, 15, 0, 0, 7327, 7328, + 7, 8, 0, 0, 7328, 1112, 1, 0, 0, 0, 7329, 7330, 7, 25, 0, 0, 7330, 7331, + 7, 5, 0, 0, 7331, 7332, 7, 17, 0, 0, 7332, 7333, 7, 22, 0, 0, 7333, 7334, + 7, 15, 0, 0, 7334, 7335, 7, 12, 0, 0, 7335, 7336, 7, 11, 0, 0, 7336, 1114, + 1, 0, 0, 0, 7337, 7338, 7, 25, 0, 0, 7338, 7339, 7, 19, 0, 0, 7339, 7340, + 7, 8, 0, 0, 7340, 7341, 7, 6, 0, 0, 7341, 1116, 1, 0, 0, 0, 7342, 7343, + 7, 25, 0, 0, 7343, 7344, 7, 8, 0, 0, 7344, 7345, 7, 7, 0, 0, 7345, 7346, + 7, 14, 0, 0, 7346, 7347, 7, 7, 0, 0, 7347, 7348, 7, 4, 0, 0, 7348, 7349, + 7, 7, 0, 0, 7349, 7350, 7, 11, 0, 0, 7350, 1118, 1, 0, 0, 0, 7351, 7352, + 7, 25, 0, 0, 7352, 7353, 7, 8, 0, 0, 7353, 7354, 7, 7, 0, 0, 7354, 7355, + 7, 14, 0, 0, 7355, 7356, 7, 7, 0, 0, 7356, 7357, 7, 4, 0, 0, 7357, 7358, + 7, 15, 0, 0, 7358, 7359, 7, 12, 0, 0, 7359, 7360, 7, 22, 0, 0, 7360, 1120, + 1, 0, 0, 0, 7361, 7362, 7, 25, 0, 0, 7362, 7363, 7, 8, 0, 0, 7363, 7364, + 7, 7, 0, 0, 7364, 7365, 7, 25, 0, 0, 7365, 7366, 7, 3, 0, 0, 7366, 7367, + 7, 8, 0, 0, 7367, 7368, 7, 7, 0, 0, 7368, 1122, 1, 0, 0, 0, 7369, 7370, + 7, 25, 0, 0, 7370, 7371, 7, 8, 0, 0, 7371, 7372, 7, 7, 0, 0, 7372, 7373, + 7, 11, 0, 0, 7373, 7374, 7, 7, 0, 0, 7374, 7375, 7, 8, 0, 0, 7375, 7376, + 7, 24, 0, 0, 7376, 7377, 7, 7, 0, 0, 7377, 1124, 1, 0, 0, 0, 7378, 7379, + 7, 25, 0, 0, 7379, 7380, 7, 8, 0, 0, 7380, 7381, 7, 7, 0, 0, 7381, 7382, + 7, 24, 0, 0, 7382, 1126, 1, 0, 0, 0, 7383, 7384, 7, 25, 0, 0, 7384, 7385, + 7, 8, 0, 0, 7385, 7386, 7, 19, 0, 0, 7386, 7387, 7, 14, 0, 0, 7387, 7388, + 7, 7, 0, 0, 7388, 7389, 7, 11, 0, 0, 7389, 7390, 7, 11, 0, 0, 7390, 7391, + 7, 5, 0, 0, 7391, 7392, 7, 15, 0, 0, 7392, 7393, 7, 11, 0, 0, 7393, 7394, + 7, 6, 0, 0, 7394, 1128, 1, 0, 0, 0, 7395, 7396, 7, 25, 0, 0, 7396, 7397, + 7, 8, 0, 0, 7397, 7398, 7, 19, 0, 0, 7398, 7399, 7, 18, 0, 0, 7399, 7400, + 7, 15, 0, 0, 7400, 7401, 7, 5, 0, 0, 7401, 7402, 7, 7, 0, 0, 7402, 1130, + 1, 0, 0, 0, 7403, 7404, 7, 25, 0, 0, 7404, 7405, 7, 8, 0, 0, 7405, 7406, + 7, 19, 0, 0, 7406, 7407, 7, 18, 0, 0, 7407, 7408, 7, 15, 0, 0, 7408, 7409, + 7, 5, 0, 0, 7409, 7410, 7, 7, 0, 0, 7410, 7411, 7, 11, 0, 0, 7411, 1132, + 1, 0, 0, 0, 7412, 7413, 7, 25, 0, 0, 7413, 7414, 7, 8, 0, 0, 7414, 7415, + 7, 19, 0, 0, 7415, 7416, 7, 26, 0, 0, 7416, 7417, 7, 10, 0, 0, 7417, 1134, + 1, 0, 0, 0, 7418, 7419, 7, 28, 0, 0, 7419, 7420, 7, 17, 0, 0, 7420, 7421, + 7, 7, 0, 0, 7421, 7422, 7, 8, 0, 0, 7422, 7423, 7, 10, 0, 0, 7423, 1136, + 1, 0, 0, 0, 7424, 7425, 7, 28, 0, 0, 7425, 7426, 7, 17, 0, 0, 7426, 7427, + 7, 15, 0, 0, 7427, 7428, 7, 14, 0, 0, 7428, 7429, 7, 21, 0, 0, 7429, 1138, + 1, 0, 0, 0, 7430, 7431, 7, 8, 0, 0, 7431, 7432, 7, 7, 0, 0, 7432, 7433, + 7, 16, 0, 0, 7433, 7434, 7, 17, 0, 0, 7434, 7435, 7, 15, 0, 0, 7435, 7436, + 7, 5, 0, 0, 7436, 7437, 7, 4, 0, 0, 7437, 1140, 1, 0, 0, 0, 7438, 7439, + 7, 8, 0, 0, 7439, 7440, 7, 7, 0, 0, 7440, 7441, 7, 14, 0, 0, 7441, 7442, + 7, 19, 0, 0, 7442, 7443, 7, 24, 0, 0, 7443, 7444, 7, 7, 0, 0, 7444, 7445, + 7, 8, 0, 0, 7445, 1142, 1, 0, 0, 0, 7446, 7447, 7, 8, 0, 0, 7447, 7448, + 7, 7, 0, 0, 7448, 7449, 7, 14, 0, 0, 7449, 7450, 7, 17, 0, 0, 7450, 7451, + 7, 8, 0, 0, 7451, 7452, 7, 11, 0, 0, 7452, 7453, 7, 15, 0, 0, 7453, 7454, + 7, 24, 0, 0, 7454, 7455, 7, 7, 0, 0, 7455, 1144, 1, 0, 0, 0, 7456, 7457, + 7, 8, 0, 0, 7457, 7458, 7, 7, 0, 0, 7458, 7459, 7, 4, 0, 0, 7459, 7460, + 7, 19, 0, 0, 7460, 7461, 5, 95, 0, 0, 7461, 7462, 7, 16, 0, 0, 7462, 7463, + 7, 17, 0, 0, 7463, 7464, 7, 18, 0, 0, 7464, 7465, 7, 18, 0, 0, 7465, 7466, + 7, 7, 0, 0, 7466, 7467, 7, 8, 0, 0, 7467, 7468, 5, 95, 0, 0, 7468, 7469, + 7, 11, 0, 0, 7469, 7470, 7, 15, 0, 0, 7470, 7471, 7, 13, 0, 0, 7471, 7472, + 7, 7, 0, 0, 7472, 1146, 1, 0, 0, 0, 7473, 7474, 7, 8, 0, 0, 7474, 7475, + 7, 7, 0, 0, 7475, 7476, 7, 4, 0, 0, 7476, 7477, 7, 17, 0, 0, 7477, 7478, + 7, 12, 0, 0, 7478, 7479, 7, 4, 0, 0, 7479, 7480, 7, 3, 0, 0, 7480, 7481, + 7, 12, 0, 0, 7481, 7482, 7, 6, 0, 0, 7482, 1148, 1, 0, 0, 0, 7483, 7484, + 7, 8, 0, 0, 7484, 7485, 7, 7, 0, 0, 7485, 7486, 7, 5, 0, 0, 7486, 7487, + 7, 3, 0, 0, 7487, 7488, 7, 10, 0, 0, 7488, 1150, 1, 0, 0, 0, 7489, 7490, + 7, 8, 0, 0, 7490, 7491, 7, 7, 0, 0, 7491, 7492, 7, 5, 0, 0, 7492, 7493, + 7, 3, 0, 0, 7493, 7494, 7, 10, 0, 0, 7494, 7495, 5, 95, 0, 0, 7495, 7496, + 7, 5, 0, 0, 7496, 7497, 7, 19, 0, 0, 7497, 7498, 7, 22, 0, 0, 7498, 7499, + 5, 95, 0, 0, 7499, 7500, 7, 18, 0, 0, 7500, 7501, 7, 15, 0, 0, 7501, 7502, + 7, 5, 0, 0, 7502, 7503, 7, 7, 0, 0, 7503, 1152, 1, 0, 0, 0, 7504, 7505, + 7, 8, 0, 0, 7505, 7506, 7, 7, 0, 0, 7506, 7507, 7, 5, 0, 0, 7507, 7508, + 7, 3, 0, 0, 7508, 7509, 7, 10, 0, 0, 7509, 7510, 5, 95, 0, 0, 7510, 7511, + 7, 5, 0, 0, 7511, 7512, 7, 19, 0, 0, 7512, 7513, 7, 22, 0, 0, 7513, 7514, + 5, 95, 0, 0, 7514, 7515, 7, 25, 0, 0, 7515, 7516, 7, 19, 0, 0, 7516, 7517, + 7, 11, 0, 0, 7517, 1154, 1, 0, 0, 0, 7518, 7519, 7, 8, 0, 0, 7519, 7520, + 7, 7, 0, 0, 7520, 7521, 7, 5, 0, 0, 7521, 7522, 7, 3, 0, 0, 7522, 7523, + 7, 10, 0, 0, 7523, 7524, 7, 5, 0, 0, 7524, 7525, 7, 19, 0, 0, 7525, 7526, + 7, 22, 0, 0, 7526, 1156, 1, 0, 0, 0, 7527, 7528, 7, 8, 0, 0, 7528, 7529, + 7, 7, 0, 0, 7529, 7530, 7, 23, 0, 0, 7530, 7531, 7, 19, 0, 0, 7531, 7532, + 7, 24, 0, 0, 7532, 7533, 7, 7, 0, 0, 7533, 1158, 1, 0, 0, 0, 7534, 7535, + 7, 8, 0, 0, 7535, 7536, 7, 7, 0, 0, 7536, 7537, 7, 19, 0, 0, 7537, 7538, + 7, 8, 0, 0, 7538, 7539, 7, 22, 0, 0, 7539, 7540, 7, 3, 0, 0, 7540, 7541, + 7, 12, 0, 0, 7541, 7542, 7, 15, 0, 0, 7542, 7543, 7, 13, 0, 0, 7543, 7544, + 7, 7, 0, 0, 7544, 1160, 1, 0, 0, 0, 7545, 7546, 7, 8, 0, 0, 7546, 7547, + 7, 7, 0, 0, 7547, 7548, 7, 25, 0, 0, 7548, 7549, 7, 3, 0, 0, 7549, 7550, + 7, 15, 0, 0, 7550, 7551, 7, 8, 0, 0, 7551, 1162, 1, 0, 0, 0, 7552, 7553, + 7, 8, 0, 0, 7553, 7554, 7, 7, 0, 0, 7554, 7555, 7, 25, 0, 0, 7555, 7556, + 7, 5, 0, 0, 7556, 7557, 7, 15, 0, 0, 7557, 7558, 7, 14, 0, 0, 7558, 7559, + 7, 3, 0, 0, 7559, 7560, 7, 6, 0, 0, 7560, 7561, 7, 7, 0, 0, 7561, 7562, + 5, 95, 0, 0, 7562, 7563, 7, 4, 0, 0, 7563, 7564, 7, 19, 0, 0, 7564, 7565, + 5, 95, 0, 0, 7565, 7566, 7, 4, 0, 0, 7566, 7567, 7, 16, 0, 0, 7567, 1164, + 1, 0, 0, 0, 7568, 7569, 7, 8, 0, 0, 7569, 7570, 7, 7, 0, 0, 7570, 7571, + 7, 25, 0, 0, 7571, 7572, 7, 5, 0, 0, 7572, 7573, 7, 15, 0, 0, 7573, 7574, + 7, 14, 0, 0, 7574, 7575, 7, 3, 0, 0, 7575, 7576, 7, 6, 0, 0, 7576, 7577, + 7, 7, 0, 0, 7577, 7578, 5, 95, 0, 0, 7578, 7579, 7, 4, 0, 0, 7579, 7580, + 7, 19, 0, 0, 7580, 7581, 5, 95, 0, 0, 7581, 7582, 7, 6, 0, 0, 7582, 7583, + 7, 3, 0, 0, 7583, 7584, 7, 16, 0, 0, 7584, 7585, 7, 5, 0, 0, 7585, 7586, + 7, 7, 0, 0, 7586, 1166, 1, 0, 0, 0, 7587, 7588, 7, 8, 0, 0, 7588, 7589, + 7, 7, 0, 0, 7589, 7590, 7, 25, 0, 0, 7590, 7591, 7, 5, 0, 0, 7591, 7592, + 7, 15, 0, 0, 7592, 7593, 7, 14, 0, 0, 7593, 7594, 7, 3, 0, 0, 7594, 7595, + 7, 6, 0, 0, 7595, 7596, 7, 7, 0, 0, 7596, 7597, 5, 95, 0, 0, 7597, 7598, + 7, 15, 0, 0, 7598, 7599, 7, 22, 0, 0, 7599, 7600, 7, 12, 0, 0, 7600, 7601, + 7, 19, 0, 0, 7601, 7602, 7, 8, 0, 0, 7602, 7603, 7, 7, 0, 0, 7603, 7604, + 5, 95, 0, 0, 7604, 7605, 7, 4, 0, 0, 7605, 7606, 7, 16, 0, 0, 7606, 1168, + 1, 0, 0, 0, 7607, 7608, 7, 8, 0, 0, 7608, 7609, 7, 7, 0, 0, 7609, 7610, + 7, 25, 0, 0, 7610, 7611, 7, 5, 0, 0, 7611, 7612, 7, 15, 0, 0, 7612, 7613, + 7, 14, 0, 0, 7613, 7614, 7, 3, 0, 0, 7614, 7615, 7, 6, 0, 0, 7615, 7616, + 7, 7, 0, 0, 7616, 7617, 5, 95, 0, 0, 7617, 7618, 7, 15, 0, 0, 7618, 7619, + 7, 22, 0, 0, 7619, 7620, 7, 12, 0, 0, 7620, 7621, 7, 19, 0, 0, 7621, 7622, + 7, 8, 0, 0, 7622, 7623, 7, 7, 0, 0, 7623, 7624, 5, 95, 0, 0, 7624, 7625, + 7, 6, 0, 0, 7625, 7626, 7, 3, 0, 0, 7626, 7627, 7, 16, 0, 0, 7627, 7628, + 7, 5, 0, 0, 7628, 7629, 7, 7, 0, 0, 7629, 1170, 1, 0, 0, 0, 7630, 7631, + 7, 8, 0, 0, 7631, 7632, 7, 7, 0, 0, 7632, 7633, 7, 25, 0, 0, 7633, 7634, + 7, 5, 0, 0, 7634, 7635, 7, 15, 0, 0, 7635, 7636, 7, 14, 0, 0, 7636, 7637, + 7, 3, 0, 0, 7637, 7638, 7, 6, 0, 0, 7638, 7639, 7, 7, 0, 0, 7639, 7640, + 5, 95, 0, 0, 7640, 7641, 7, 8, 0, 0, 7641, 7642, 7, 7, 0, 0, 7642, 7643, + 7, 9, 0, 0, 7643, 7644, 7, 8, 0, 0, 7644, 7645, 7, 15, 0, 0, 7645, 7646, + 7, 6, 0, 0, 7646, 7647, 7, 7, 0, 0, 7647, 7648, 5, 95, 0, 0, 7648, 7649, + 7, 4, 0, 0, 7649, 7650, 7, 16, 0, 0, 7650, 1172, 1, 0, 0, 0, 7651, 7652, + 7, 8, 0, 0, 7652, 7653, 7, 7, 0, 0, 7653, 7654, 7, 25, 0, 0, 7654, 7655, + 7, 5, 0, 0, 7655, 7656, 7, 15, 0, 0, 7656, 7657, 7, 14, 0, 0, 7657, 7658, + 7, 3, 0, 0, 7658, 7659, 7, 6, 0, 0, 7659, 7660, 7, 7, 0, 0, 7660, 7661, + 5, 95, 0, 0, 7661, 7662, 7, 9, 0, 0, 7662, 7663, 7, 15, 0, 0, 7663, 7664, + 7, 5, 0, 0, 7664, 7665, 7, 4, 0, 0, 7665, 7666, 5, 95, 0, 0, 7666, 7667, + 7, 4, 0, 0, 7667, 7668, 7, 19, 0, 0, 7668, 7669, 5, 95, 0, 0, 7669, 7670, + 7, 6, 0, 0, 7670, 7671, 7, 3, 0, 0, 7671, 7672, 7, 16, 0, 0, 7672, 7673, + 7, 5, 0, 0, 7673, 7674, 7, 7, 0, 0, 7674, 1174, 1, 0, 0, 0, 7675, 7676, + 7, 8, 0, 0, 7676, 7677, 7, 7, 0, 0, 7677, 7678, 7, 25, 0, 0, 7678, 7679, + 7, 5, 0, 0, 7679, 7680, 7, 15, 0, 0, 7680, 7681, 7, 14, 0, 0, 7681, 7682, + 7, 3, 0, 0, 7682, 7683, 7, 6, 0, 0, 7683, 7684, 7, 7, 0, 0, 7684, 7685, + 5, 95, 0, 0, 7685, 7686, 7, 9, 0, 0, 7686, 7687, 7, 15, 0, 0, 7687, 7688, + 7, 5, 0, 0, 7688, 7689, 7, 4, 0, 0, 7689, 7690, 5, 95, 0, 0, 7690, 7691, + 7, 15, 0, 0, 7691, 7692, 7, 22, 0, 0, 7692, 7693, 7, 12, 0, 0, 7693, 7694, + 7, 19, 0, 0, 7694, 7695, 7, 8, 0, 0, 7695, 7696, 7, 7, 0, 0, 7696, 7697, + 5, 95, 0, 0, 7697, 7698, 7, 6, 0, 0, 7698, 7699, 7, 3, 0, 0, 7699, 7700, + 7, 16, 0, 0, 7700, 7701, 7, 5, 0, 0, 7701, 7702, 7, 7, 0, 0, 7702, 1176, + 1, 0, 0, 0, 7703, 7704, 7, 8, 0, 0, 7704, 7705, 7, 7, 0, 0, 7705, 7706, + 7, 25, 0, 0, 7706, 7707, 7, 5, 0, 0, 7707, 7708, 7, 15, 0, 0, 7708, 7709, + 7, 14, 0, 0, 7709, 7710, 7, 3, 0, 0, 7710, 7711, 7, 6, 0, 0, 7711, 7712, + 7, 15, 0, 0, 7712, 7713, 7, 19, 0, 0, 7713, 7714, 7, 12, 0, 0, 7714, 1178, + 1, 0, 0, 0, 7715, 7716, 7, 8, 0, 0, 7716, 7717, 7, 7, 0, 0, 7717, 7718, + 7, 11, 0, 0, 7718, 7719, 7, 7, 0, 0, 7719, 7720, 7, 6, 0, 0, 7720, 1180, + 1, 0, 0, 0, 7721, 7722, 7, 8, 0, 0, 7722, 7723, 7, 7, 0, 0, 7723, 7724, + 7, 11, 0, 0, 7724, 7725, 7, 6, 0, 0, 7725, 7726, 7, 3, 0, 0, 7726, 7727, + 7, 8, 0, 0, 7727, 7728, 7, 6, 0, 0, 7728, 1182, 1, 0, 0, 0, 7729, 7730, + 7, 8, 0, 0, 7730, 7731, 7, 7, 0, 0, 7731, 7732, 7, 11, 0, 0, 7732, 7733, + 7, 17, 0, 0, 7733, 7734, 7, 23, 0, 0, 7734, 7735, 7, 7, 0, 0, 7735, 1184, + 1, 0, 0, 0, 7736, 7737, 7, 8, 0, 0, 7737, 7738, 7, 7, 0, 0, 7738, 7739, + 7, 6, 0, 0, 7739, 7740, 7, 17, 0, 0, 7740, 7741, 7, 8, 0, 0, 7741, 7742, + 7, 12, 0, 0, 7742, 7743, 7, 7, 0, 0, 7743, 7744, 7, 4, 0, 0, 7744, 7745, + 5, 95, 0, 0, 7745, 7746, 7, 11, 0, 0, 7746, 7747, 7, 28, 0, 0, 7747, 7748, + 7, 5, 0, 0, 7748, 7749, 7, 11, 0, 0, 7749, 7750, 7, 6, 0, 0, 7750, 7751, + 7, 3, 0, 0, 7751, 7752, 7, 6, 0, 0, 7752, 7753, 7, 7, 0, 0, 7753, 1186, + 1, 0, 0, 0, 7754, 7755, 7, 8, 0, 0, 7755, 7756, 7, 7, 0, 0, 7756, 7757, + 7, 6, 0, 0, 7757, 7758, 7, 17, 0, 0, 7758, 7759, 7, 8, 0, 0, 7759, 7760, + 7, 12, 0, 0, 7760, 7761, 7, 15, 0, 0, 7761, 7762, 7, 12, 0, 0, 7762, 7763, + 7, 22, 0, 0, 7763, 1188, 1, 0, 0, 0, 7764, 7765, 7, 8, 0, 0, 7765, 7766, + 7, 7, 0, 0, 7766, 7767, 7, 6, 0, 0, 7767, 7768, 7, 17, 0, 0, 7768, 7769, + 7, 8, 0, 0, 7769, 7770, 7, 12, 0, 0, 7770, 7771, 7, 11, 0, 0, 7771, 1190, + 1, 0, 0, 0, 7772, 7773, 7, 8, 0, 0, 7773, 7774, 7, 7, 0, 0, 7774, 7775, + 7, 17, 0, 0, 7775, 7776, 7, 11, 0, 0, 7776, 7777, 7, 7, 0, 0, 7777, 1192, + 1, 0, 0, 0, 7778, 7779, 7, 8, 0, 0, 7779, 7780, 7, 19, 0, 0, 7780, 7781, + 7, 5, 0, 0, 7781, 7782, 7, 7, 0, 0, 7782, 1194, 1, 0, 0, 0, 7783, 7784, + 7, 8, 0, 0, 7784, 7785, 7, 19, 0, 0, 7785, 7786, 7, 5, 0, 0, 7786, 7787, + 7, 5, 0, 0, 7787, 7788, 7, 16, 0, 0, 7788, 7789, 7, 3, 0, 0, 7789, 7790, + 7, 14, 0, 0, 7790, 7791, 7, 21, 0, 0, 7791, 1196, 1, 0, 0, 0, 7792, 7793, + 7, 8, 0, 0, 7793, 7794, 7, 19, 0, 0, 7794, 7795, 7, 5, 0, 0, 7795, 7796, + 7, 5, 0, 0, 7796, 7797, 7, 17, 0, 0, 7797, 7798, 7, 25, 0, 0, 7798, 1198, + 1, 0, 0, 0, 7799, 7800, 7, 8, 0, 0, 7800, 7801, 7, 19, 0, 0, 7801, 7802, + 7, 6, 0, 0, 7802, 7803, 7, 3, 0, 0, 7803, 7804, 7, 6, 0, 0, 7804, 7805, + 7, 7, 0, 0, 7805, 1200, 1, 0, 0, 0, 7806, 7807, 7, 8, 0, 0, 7807, 7808, + 7, 19, 0, 0, 7808, 7809, 7, 9, 0, 0, 7809, 1202, 1, 0, 0, 0, 7810, 7811, + 7, 8, 0, 0, 7811, 7812, 7, 19, 0, 0, 7812, 7813, 7, 9, 0, 0, 7813, 7814, + 7, 11, 0, 0, 7814, 1204, 1, 0, 0, 0, 7815, 7816, 7, 8, 0, 0, 7816, 7817, + 7, 19, 0, 0, 7817, 7818, 7, 9, 0, 0, 7818, 7819, 5, 95, 0, 0, 7819, 7820, + 7, 18, 0, 0, 7820, 7821, 7, 19, 0, 0, 7821, 7822, 7, 8, 0, 0, 7822, 7823, + 7, 23, 0, 0, 7823, 7824, 7, 3, 0, 0, 7824, 7825, 7, 6, 0, 0, 7825, 1206, + 1, 0, 0, 0, 7826, 7827, 7, 8, 0, 0, 7827, 7828, 7, 6, 0, 0, 7828, 7829, + 7, 8, 0, 0, 7829, 7830, 7, 7, 0, 0, 7830, 7831, 7, 7, 0, 0, 7831, 1208, + 1, 0, 0, 0, 7832, 7833, 7, 11, 0, 0, 7833, 7834, 7, 3, 0, 0, 7834, 7835, + 7, 24, 0, 0, 7835, 7836, 7, 7, 0, 0, 7836, 7837, 7, 25, 0, 0, 7837, 7838, + 7, 19, 0, 0, 7838, 7839, 7, 15, 0, 0, 7839, 7840, 7, 12, 0, 0, 7840, 7841, + 7, 6, 0, 0, 7841, 1210, 1, 0, 0, 0, 7842, 7843, 7, 11, 0, 0, 7843, 7844, + 7, 14, 0, 0, 7844, 7845, 7, 20, 0, 0, 7845, 7846, 7, 7, 0, 0, 7846, 7847, + 7, 4, 0, 0, 7847, 7848, 7, 17, 0, 0, 7848, 7849, 7, 5, 0, 0, 7849, 7850, + 7, 7, 0, 0, 7850, 1212, 1, 0, 0, 0, 7851, 7852, 7, 11, 0, 0, 7852, 7853, + 7, 7, 0, 0, 7853, 7854, 7, 14, 0, 0, 7854, 7855, 7, 17, 0, 0, 7855, 7856, + 7, 8, 0, 0, 7856, 7857, 7, 15, 0, 0, 7857, 7858, 7, 6, 0, 0, 7858, 7859, + 7, 10, 0, 0, 7859, 1214, 1, 0, 0, 0, 7860, 7861, 7, 11, 0, 0, 7861, 7862, + 7, 7, 0, 0, 7862, 7863, 7, 28, 0, 0, 7863, 7864, 7, 17, 0, 0, 7864, 7865, + 7, 7, 0, 0, 7865, 7866, 7, 12, 0, 0, 7866, 7867, 7, 14, 0, 0, 7867, 7868, + 7, 7, 0, 0, 7868, 1216, 1, 0, 0, 0, 7869, 7870, 7, 11, 0, 0, 7870, 7871, + 7, 7, 0, 0, 7871, 7872, 7, 8, 0, 0, 7872, 7873, 7, 24, 0, 0, 7873, 7874, + 7, 7, 0, 0, 7874, 7875, 7, 8, 0, 0, 7875, 1218, 1, 0, 0, 0, 7876, 7877, + 7, 11, 0, 0, 7877, 7878, 7, 7, 0, 0, 7878, 7879, 7, 11, 0, 0, 7879, 7880, + 7, 11, 0, 0, 7880, 7881, 7, 15, 0, 0, 7881, 7882, 7, 19, 0, 0, 7882, 7883, + 7, 12, 0, 0, 7883, 1220, 1, 0, 0, 0, 7884, 7885, 7, 11, 0, 0, 7885, 7886, + 7, 20, 0, 0, 7886, 7887, 7, 3, 0, 0, 7887, 7888, 7, 8, 0, 0, 7888, 7889, + 7, 7, 0, 0, 7889, 1222, 1, 0, 0, 0, 7890, 7891, 7, 11, 0, 0, 7891, 7892, + 7, 20, 0, 0, 7892, 7893, 7, 3, 0, 0, 7893, 7894, 7, 8, 0, 0, 7894, 7895, + 7, 7, 0, 0, 7895, 7896, 7, 4, 0, 0, 7896, 1224, 1, 0, 0, 0, 7897, 7898, + 7, 11, 0, 0, 7898, 7899, 7, 15, 0, 0, 7899, 7900, 7, 22, 0, 0, 7900, 7901, + 7, 12, 0, 0, 7901, 7902, 7, 7, 0, 0, 7902, 7903, 7, 4, 0, 0, 7903, 1226, + 1, 0, 0, 0, 7904, 7905, 7, 11, 0, 0, 7905, 7906, 7, 15, 0, 0, 7906, 7907, + 7, 23, 0, 0, 7907, 7908, 7, 25, 0, 0, 7908, 7909, 7, 5, 0, 0, 7909, 7910, + 7, 7, 0, 0, 7910, 1228, 1, 0, 0, 0, 7911, 7912, 7, 11, 0, 0, 7912, 7913, + 7, 5, 0, 0, 7913, 7914, 7, 3, 0, 0, 7914, 7915, 7, 24, 0, 0, 7915, 7916, + 7, 7, 0, 0, 7916, 1230, 1, 0, 0, 0, 7917, 7918, 7, 11, 0, 0, 7918, 7919, + 7, 5, 0, 0, 7919, 7920, 7, 19, 0, 0, 7920, 7921, 7, 9, 0, 0, 7921, 1232, + 1, 0, 0, 0, 7922, 7923, 7, 11, 0, 0, 7923, 7924, 7, 12, 0, 0, 7924, 7925, + 7, 3, 0, 0, 7925, 7926, 7, 25, 0, 0, 7926, 7927, 7, 11, 0, 0, 7927, 7928, + 7, 20, 0, 0, 7928, 7929, 7, 19, 0, 0, 7929, 7930, 7, 6, 0, 0, 7930, 1234, + 1, 0, 0, 0, 7931, 7932, 7, 11, 0, 0, 7932, 7933, 7, 19, 0, 0, 7933, 7934, + 7, 14, 0, 0, 7934, 7935, 7, 21, 0, 0, 7935, 7936, 7, 7, 0, 0, 7936, 7937, + 7, 6, 0, 0, 7937, 1236, 1, 0, 0, 0, 7938, 7939, 7, 11, 0, 0, 7939, 7940, + 7, 19, 0, 0, 7940, 7941, 7, 23, 0, 0, 7941, 7942, 7, 7, 0, 0, 7942, 1238, + 1, 0, 0, 0, 7943, 7944, 7, 11, 0, 0, 7944, 7945, 7, 19, 0, 0, 7945, 7946, + 7, 12, 0, 0, 7946, 7947, 7, 3, 0, 0, 7947, 7948, 7, 23, 0, 0, 7948, 7949, + 7, 7, 0, 0, 7949, 1240, 1, 0, 0, 0, 7950, 7951, 7, 11, 0, 0, 7951, 7952, + 7, 19, 0, 0, 7952, 7953, 7, 17, 0, 0, 7953, 7954, 7, 12, 0, 0, 7954, 7955, + 7, 4, 0, 0, 7955, 7956, 7, 11, 0, 0, 7956, 1242, 1, 0, 0, 0, 7957, 7958, + 7, 11, 0, 0, 7958, 7959, 7, 19, 0, 0, 7959, 7960, 7, 17, 0, 0, 7960, 7961, + 7, 8, 0, 0, 7961, 7962, 7, 14, 0, 0, 7962, 7963, 7, 7, 0, 0, 7963, 1244, + 1, 0, 0, 0, 7964, 7965, 7, 11, 0, 0, 7965, 7966, 7, 28, 0, 0, 7966, 7967, + 7, 5, 0, 0, 7967, 7968, 5, 95, 0, 0, 7968, 7969, 7, 3, 0, 0, 7969, 7970, + 7, 18, 0, 0, 7970, 7971, 7, 6, 0, 0, 7971, 7972, 7, 7, 0, 0, 7972, 7973, + 7, 8, 0, 0, 7973, 7974, 5, 95, 0, 0, 7974, 7975, 7, 22, 0, 0, 7975, 7976, + 7, 6, 0, 0, 7976, 7977, 7, 15, 0, 0, 7977, 7978, 7, 4, 0, 0, 7978, 7979, + 7, 11, 0, 0, 7979, 1246, 1, 0, 0, 0, 7980, 7981, 7, 11, 0, 0, 7981, 7982, + 7, 28, 0, 0, 7982, 7983, 7, 5, 0, 0, 7983, 7984, 5, 95, 0, 0, 7984, 7985, + 7, 3, 0, 0, 7985, 7986, 7, 18, 0, 0, 7986, 7987, 7, 6, 0, 0, 7987, 7988, + 7, 7, 0, 0, 7988, 7989, 7, 8, 0, 0, 7989, 7990, 5, 95, 0, 0, 7990, 7991, + 7, 23, 0, 0, 7991, 7992, 7, 6, 0, 0, 7992, 7993, 7, 11, 0, 0, 7993, 7994, + 5, 95, 0, 0, 7994, 7995, 7, 22, 0, 0, 7995, 7996, 7, 3, 0, 0, 7996, 7997, + 7, 25, 0, 0, 7997, 7998, 7, 11, 0, 0, 7998, 1248, 1, 0, 0, 0, 7999, 8000, + 7, 11, 0, 0, 8000, 8001, 7, 28, 0, 0, 8001, 8002, 7, 5, 0, 0, 8002, 8003, + 5, 95, 0, 0, 8003, 8004, 7, 16, 0, 0, 8004, 8005, 7, 7, 0, 0, 8005, 8006, + 7, 18, 0, 0, 8006, 8007, 7, 19, 0, 0, 8007, 8008, 7, 8, 0, 0, 8008, 8009, + 7, 7, 0, 0, 8009, 8010, 5, 95, 0, 0, 8010, 8011, 7, 22, 0, 0, 8011, 8012, + 7, 6, 0, 0, 8012, 8013, 7, 15, 0, 0, 8013, 8014, 7, 4, 0, 0, 8014, 8015, + 7, 11, 0, 0, 8015, 1250, 1, 0, 0, 0, 8016, 8017, 7, 11, 0, 0, 8017, 8018, + 7, 28, 0, 0, 8018, 8019, 7, 5, 0, 0, 8019, 8020, 5, 95, 0, 0, 8020, 8021, + 7, 16, 0, 0, 8021, 8022, 7, 17, 0, 0, 8022, 8023, 7, 18, 0, 0, 8023, 8024, + 7, 18, 0, 0, 8024, 8025, 7, 7, 0, 0, 8025, 8026, 7, 8, 0, 0, 8026, 8027, + 5, 95, 0, 0, 8027, 8028, 7, 8, 0, 0, 8028, 8029, 7, 7, 0, 0, 8029, 8030, + 7, 11, 0, 0, 8030, 8031, 7, 17, 0, 0, 8031, 8032, 7, 5, 0, 0, 8032, 8033, + 7, 6, 0, 0, 8033, 1252, 1, 0, 0, 0, 8034, 8035, 7, 11, 0, 0, 8035, 8036, + 7, 28, 0, 0, 8036, 8037, 7, 5, 0, 0, 8037, 8038, 5, 95, 0, 0, 8038, 8039, + 7, 14, 0, 0, 8039, 8040, 7, 3, 0, 0, 8040, 8041, 7, 14, 0, 0, 8041, 8042, + 7, 20, 0, 0, 8042, 8043, 7, 7, 0, 0, 8043, 1254, 1, 0, 0, 0, 8044, 8045, + 7, 11, 0, 0, 8045, 8046, 7, 28, 0, 0, 8046, 8047, 7, 5, 0, 0, 8047, 8048, + 5, 95, 0, 0, 8048, 8049, 7, 12, 0, 0, 8049, 8050, 7, 19, 0, 0, 8050, 8051, + 5, 95, 0, 0, 8051, 8052, 7, 14, 0, 0, 8052, 8053, 7, 3, 0, 0, 8053, 8054, + 7, 14, 0, 0, 8054, 8055, 7, 20, 0, 0, 8055, 8056, 7, 7, 0, 0, 8056, 1256, + 1, 0, 0, 0, 8057, 8058, 7, 11, 0, 0, 8058, 8059, 7, 28, 0, 0, 8059, 8060, + 7, 5, 0, 0, 8060, 8061, 5, 95, 0, 0, 8061, 8062, 7, 6, 0, 0, 8062, 8063, + 7, 20, 0, 0, 8063, 8064, 7, 8, 0, 0, 8064, 8065, 7, 7, 0, 0, 8065, 8066, + 7, 3, 0, 0, 8066, 8067, 7, 4, 0, 0, 8067, 1258, 1, 0, 0, 0, 8068, 8069, + 7, 11, 0, 0, 8069, 8070, 7, 6, 0, 0, 8070, 8071, 7, 3, 0, 0, 8071, 8072, + 7, 8, 0, 0, 8072, 8073, 7, 6, 0, 0, 8073, 1260, 1, 0, 0, 0, 8074, 8075, + 7, 11, 0, 0, 8075, 8076, 7, 6, 0, 0, 8076, 8077, 7, 3, 0, 0, 8077, 8078, + 7, 8, 0, 0, 8078, 8079, 7, 6, 0, 0, 8079, 8080, 7, 11, 0, 0, 8080, 1262, + 1, 0, 0, 0, 8081, 8082, 7, 11, 0, 0, 8082, 8083, 7, 6, 0, 0, 8083, 8084, + 7, 3, 0, 0, 8084, 8085, 7, 6, 0, 0, 8085, 8086, 7, 11, 0, 0, 8086, 8087, + 5, 95, 0, 0, 8087, 8088, 7, 3, 0, 0, 8088, 8089, 7, 17, 0, 0, 8089, 8090, + 7, 6, 0, 0, 8090, 8091, 7, 19, 0, 0, 8091, 8092, 5, 95, 0, 0, 8092, 8093, + 7, 8, 0, 0, 8093, 8094, 7, 7, 0, 0, 8094, 8095, 7, 14, 0, 0, 8095, 8096, + 7, 3, 0, 0, 8096, 8097, 7, 5, 0, 0, 8097, 8098, 7, 14, 0, 0, 8098, 1264, + 1, 0, 0, 0, 8099, 8100, 7, 11, 0, 0, 8100, 8101, 7, 6, 0, 0, 8101, 8102, + 7, 3, 0, 0, 8102, 8103, 7, 6, 0, 0, 8103, 8104, 7, 11, 0, 0, 8104, 8105, + 5, 95, 0, 0, 8105, 8106, 7, 25, 0, 0, 8106, 8107, 7, 7, 0, 0, 8107, 8108, + 7, 8, 0, 0, 8108, 8109, 7, 11, 0, 0, 8109, 8110, 7, 15, 0, 0, 8110, 8111, + 7, 11, 0, 0, 8111, 8112, 7, 6, 0, 0, 8112, 8113, 7, 7, 0, 0, 8113, 8114, + 7, 12, 0, 0, 8114, 8115, 7, 6, 0, 0, 8115, 1266, 1, 0, 0, 0, 8116, 8117, + 7, 11, 0, 0, 8117, 8118, 7, 6, 0, 0, 8118, 8119, 7, 3, 0, 0, 8119, 8120, + 7, 6, 0, 0, 8120, 8121, 7, 11, 0, 0, 8121, 8122, 5, 95, 0, 0, 8122, 8123, + 7, 11, 0, 0, 8123, 8124, 7, 3, 0, 0, 8124, 8125, 7, 23, 0, 0, 8125, 8126, + 7, 25, 0, 0, 8126, 8127, 7, 5, 0, 0, 8127, 8128, 7, 7, 0, 0, 8128, 8129, + 5, 95, 0, 0, 8129, 8130, 7, 25, 0, 0, 8130, 8131, 7, 3, 0, 0, 8131, 8132, + 7, 22, 0, 0, 8132, 8133, 7, 7, 0, 0, 8133, 8134, 7, 11, 0, 0, 8134, 1268, + 1, 0, 0, 0, 8135, 8136, 7, 11, 0, 0, 8136, 8137, 7, 6, 0, 0, 8137, 8138, + 7, 3, 0, 0, 8138, 8139, 7, 6, 0, 0, 8139, 8140, 7, 17, 0, 0, 8140, 8141, + 7, 11, 0, 0, 8141, 1270, 1, 0, 0, 0, 8142, 8143, 7, 11, 0, 0, 8143, 8144, + 7, 6, 0, 0, 8144, 8145, 7, 19, 0, 0, 8145, 8146, 7, 25, 0, 0, 8146, 1272, + 1, 0, 0, 0, 8147, 8148, 7, 11, 0, 0, 8148, 8149, 7, 6, 0, 0, 8149, 8150, + 7, 19, 0, 0, 8150, 8151, 7, 8, 0, 0, 8151, 8152, 7, 3, 0, 0, 8152, 8153, + 7, 22, 0, 0, 8153, 8154, 7, 7, 0, 0, 8154, 1274, 1, 0, 0, 0, 8155, 8156, + 7, 11, 0, 0, 8156, 8157, 7, 6, 0, 0, 8157, 8158, 7, 19, 0, 0, 8158, 8159, + 7, 8, 0, 0, 8159, 8160, 7, 7, 0, 0, 8160, 8161, 7, 4, 0, 0, 8161, 1276, + 1, 0, 0, 0, 8162, 8163, 7, 11, 0, 0, 8163, 8164, 7, 6, 0, 0, 8164, 8165, + 7, 8, 0, 0, 8165, 8166, 7, 15, 0, 0, 8166, 8167, 7, 12, 0, 0, 8167, 8168, + 7, 22, 0, 0, 8168, 1278, 1, 0, 0, 0, 8169, 8170, 7, 11, 0, 0, 8170, 8171, + 7, 17, 0, 0, 8171, 8172, 7, 16, 0, 0, 8172, 8173, 7, 14, 0, 0, 8173, 8174, + 7, 5, 0, 0, 8174, 8175, 7, 3, 0, 0, 8175, 8176, 7, 11, 0, 0, 8176, 8177, + 7, 11, 0, 0, 8177, 8178, 5, 95, 0, 0, 8178, 8179, 7, 19, 0, 0, 8179, 8180, + 7, 8, 0, 0, 8180, 8181, 7, 15, 0, 0, 8181, 8182, 7, 22, 0, 0, 8182, 8183, + 7, 15, 0, 0, 8183, 8184, 7, 12, 0, 0, 8184, 1280, 1, 0, 0, 0, 8185, 8186, + 7, 11, 0, 0, 8186, 8187, 7, 17, 0, 0, 8187, 8188, 7, 16, 0, 0, 8188, 8189, + 7, 27, 0, 0, 8189, 8190, 7, 7, 0, 0, 8190, 8191, 7, 14, 0, 0, 8191, 8192, + 7, 6, 0, 0, 8192, 1282, 1, 0, 0, 0, 8193, 8194, 7, 11, 0, 0, 8194, 8195, + 7, 17, 0, 0, 8195, 8196, 7, 16, 0, 0, 8196, 8197, 7, 25, 0, 0, 8197, 8198, + 7, 3, 0, 0, 8198, 8199, 7, 8, 0, 0, 8199, 8200, 7, 6, 0, 0, 8200, 8201, + 7, 15, 0, 0, 8201, 8202, 7, 6, 0, 0, 8202, 8203, 7, 15, 0, 0, 8203, 8204, + 7, 19, 0, 0, 8204, 8205, 7, 12, 0, 0, 8205, 1284, 1, 0, 0, 0, 8206, 8207, + 7, 11, 0, 0, 8207, 8208, 7, 17, 0, 0, 8208, 8209, 7, 16, 0, 0, 8209, 8210, + 7, 25, 0, 0, 8210, 8211, 7, 3, 0, 0, 8211, 8212, 7, 8, 0, 0, 8212, 8213, + 7, 6, 0, 0, 8213, 8214, 7, 15, 0, 0, 8214, 8215, 7, 6, 0, 0, 8215, 8216, + 7, 15, 0, 0, 8216, 8217, 7, 19, 0, 0, 8217, 8218, 7, 12, 0, 0, 8218, 8219, + 7, 11, 0, 0, 8219, 1286, 1, 0, 0, 0, 8220, 8221, 7, 11, 0, 0, 8221, 8222, + 7, 17, 0, 0, 8222, 8223, 7, 11, 0, 0, 8223, 8224, 7, 25, 0, 0, 8224, 8225, + 7, 7, 0, 0, 8225, 8226, 7, 12, 0, 0, 8226, 8227, 7, 4, 0, 0, 8227, 1288, + 1, 0, 0, 0, 8228, 8229, 7, 11, 0, 0, 8229, 8230, 7, 9, 0, 0, 8230, 8231, + 7, 3, 0, 0, 8231, 8232, 7, 25, 0, 0, 8232, 8233, 7, 11, 0, 0, 8233, 1290, + 1, 0, 0, 0, 8234, 8235, 7, 11, 0, 0, 8235, 8236, 7, 9, 0, 0, 8236, 8237, + 7, 15, 0, 0, 8237, 8238, 7, 6, 0, 0, 8238, 8239, 7, 14, 0, 0, 8239, 8240, + 7, 20, 0, 0, 8240, 8241, 7, 7, 0, 0, 8241, 8242, 7, 11, 0, 0, 8242, 1292, + 1, 0, 0, 0, 8243, 8244, 7, 6, 0, 0, 8244, 8245, 7, 3, 0, 0, 8245, 8246, + 7, 16, 0, 0, 8246, 8247, 7, 5, 0, 0, 8247, 8248, 7, 7, 0, 0, 8248, 8249, + 5, 95, 0, 0, 8249, 8250, 7, 12, 0, 0, 8250, 8251, 7, 3, 0, 0, 8251, 8252, + 7, 23, 0, 0, 8252, 8253, 7, 7, 0, 0, 8253, 1294, 1, 0, 0, 0, 8254, 8255, + 7, 6, 0, 0, 8255, 8256, 7, 3, 0, 0, 8256, 8257, 7, 16, 0, 0, 8257, 8258, + 7, 5, 0, 0, 8258, 8259, 7, 7, 0, 0, 8259, 8260, 7, 11, 0, 0, 8260, 8261, + 7, 25, 0, 0, 8261, 8262, 7, 3, 0, 0, 8262, 8263, 7, 14, 0, 0, 8263, 8264, + 7, 7, 0, 0, 8264, 1296, 1, 0, 0, 0, 8265, 8266, 7, 6, 0, 0, 8266, 8267, + 7, 3, 0, 0, 8267, 8268, 7, 16, 0, 0, 8268, 8269, 7, 5, 0, 0, 8269, 8270, + 7, 7, 0, 0, 8270, 8271, 5, 95, 0, 0, 8271, 8272, 7, 6, 0, 0, 8272, 8273, + 7, 10, 0, 0, 8273, 8274, 7, 25, 0, 0, 8274, 8275, 7, 7, 0, 0, 8275, 1298, + 1, 0, 0, 0, 8276, 8277, 7, 6, 0, 0, 8277, 8278, 7, 7, 0, 0, 8278, 8279, + 7, 23, 0, 0, 8279, 8280, 7, 25, 0, 0, 8280, 8281, 7, 19, 0, 0, 8281, 8282, + 7, 8, 0, 0, 8282, 8283, 7, 3, 0, 0, 8283, 8284, 7, 8, 0, 0, 8284, 8285, + 7, 10, 0, 0, 8285, 1300, 1, 0, 0, 0, 8286, 8287, 7, 6, 0, 0, 8287, 8288, + 7, 7, 0, 0, 8288, 8289, 7, 23, 0, 0, 8289, 8290, 7, 25, 0, 0, 8290, 8291, + 7, 6, 0, 0, 8291, 8292, 7, 3, 0, 0, 8292, 8293, 7, 16, 0, 0, 8293, 8294, + 7, 5, 0, 0, 8294, 8295, 7, 7, 0, 0, 8295, 1302, 1, 0, 0, 0, 8296, 8297, + 7, 6, 0, 0, 8297, 8298, 7, 20, 0, 0, 8298, 8299, 7, 3, 0, 0, 8299, 8300, + 7, 12, 0, 0, 8300, 1304, 1, 0, 0, 0, 8301, 8302, 7, 6, 0, 0, 8302, 8303, + 7, 8, 0, 0, 8303, 8304, 7, 3, 0, 0, 8304, 8305, 7, 4, 0, 0, 8305, 8306, + 7, 15, 0, 0, 8306, 8307, 7, 6, 0, 0, 8307, 8308, 7, 15, 0, 0, 8308, 8309, + 7, 19, 0, 0, 8309, 8310, 7, 12, 0, 0, 8310, 8311, 7, 3, 0, 0, 8311, 8312, + 7, 5, 0, 0, 8312, 1306, 1, 0, 0, 0, 8313, 8314, 7, 6, 0, 0, 8314, 8315, + 7, 8, 0, 0, 8315, 8316, 7, 3, 0, 0, 8316, 8317, 7, 12, 0, 0, 8317, 8318, + 7, 11, 0, 0, 8318, 8319, 7, 3, 0, 0, 8319, 8320, 7, 14, 0, 0, 8320, 8321, + 7, 6, 0, 0, 8321, 8322, 7, 15, 0, 0, 8322, 8323, 7, 19, 0, 0, 8323, 8324, + 7, 12, 0, 0, 8324, 1308, 1, 0, 0, 0, 8325, 8326, 7, 6, 0, 0, 8326, 8327, + 7, 8, 0, 0, 8327, 8328, 7, 3, 0, 0, 8328, 8329, 7, 12, 0, 0, 8329, 8330, + 7, 11, 0, 0, 8330, 8331, 7, 3, 0, 0, 8331, 8332, 7, 14, 0, 0, 8332, 8333, + 7, 6, 0, 0, 8333, 8334, 7, 15, 0, 0, 8334, 8335, 7, 19, 0, 0, 8335, 8336, + 7, 12, 0, 0, 8336, 8337, 7, 3, 0, 0, 8337, 8338, 7, 5, 0, 0, 8338, 1310, + 1, 0, 0, 0, 8339, 8340, 7, 6, 0, 0, 8340, 8341, 7, 8, 0, 0, 8341, 8342, + 7, 15, 0, 0, 8342, 8343, 7, 22, 0, 0, 8343, 8344, 7, 22, 0, 0, 8344, 8345, + 7, 7, 0, 0, 8345, 8346, 7, 8, 0, 0, 8346, 8347, 7, 11, 0, 0, 8347, 1312, + 1, 0, 0, 0, 8348, 8349, 7, 6, 0, 0, 8349, 8350, 7, 8, 0, 0, 8350, 8351, + 7, 17, 0, 0, 8351, 8352, 7, 12, 0, 0, 8352, 8353, 7, 14, 0, 0, 8353, 8354, + 7, 3, 0, 0, 8354, 8355, 7, 6, 0, 0, 8355, 8356, 7, 7, 0, 0, 8356, 1314, + 1, 0, 0, 0, 8357, 8358, 7, 17, 0, 0, 8358, 8359, 7, 12, 0, 0, 8359, 8360, + 7, 16, 0, 0, 8360, 8361, 7, 19, 0, 0, 8361, 8362, 7, 17, 0, 0, 8362, 8363, + 7, 12, 0, 0, 8363, 8364, 7, 4, 0, 0, 8364, 8365, 7, 7, 0, 0, 8365, 8366, + 7, 4, 0, 0, 8366, 1316, 1, 0, 0, 0, 8367, 8368, 7, 17, 0, 0, 8368, 8369, + 7, 12, 0, 0, 8369, 8370, 7, 4, 0, 0, 8370, 8371, 7, 7, 0, 0, 8371, 8372, + 7, 18, 0, 0, 8372, 8373, 7, 15, 0, 0, 8373, 8374, 7, 12, 0, 0, 8374, 8375, + 7, 7, 0, 0, 8375, 8376, 7, 4, 0, 0, 8376, 1318, 1, 0, 0, 0, 8377, 8378, + 7, 17, 0, 0, 8378, 8379, 7, 12, 0, 0, 8379, 8380, 7, 4, 0, 0, 8380, 8381, + 7, 19, 0, 0, 8381, 8382, 7, 18, 0, 0, 8382, 8383, 7, 15, 0, 0, 8383, 8384, + 7, 5, 0, 0, 8384, 8385, 7, 7, 0, 0, 8385, 1320, 1, 0, 0, 0, 8386, 8387, + 7, 17, 0, 0, 8387, 8388, 7, 12, 0, 0, 8388, 8389, 7, 4, 0, 0, 8389, 8390, + 7, 19, 0, 0, 8390, 8391, 5, 95, 0, 0, 8391, 8392, 7, 16, 0, 0, 8392, 8393, + 7, 17, 0, 0, 8393, 8394, 7, 18, 0, 0, 8394, 8395, 7, 18, 0, 0, 8395, 8396, + 7, 7, 0, 0, 8396, 8397, 7, 8, 0, 0, 8397, 8398, 5, 95, 0, 0, 8398, 8399, + 7, 11, 0, 0, 8399, 8400, 7, 15, 0, 0, 8400, 8401, 7, 13, 0, 0, 8401, 8402, + 7, 7, 0, 0, 8402, 1322, 1, 0, 0, 0, 8403, 8404, 7, 17, 0, 0, 8404, 8405, + 7, 12, 0, 0, 8405, 8406, 7, 15, 0, 0, 8406, 8407, 7, 12, 0, 0, 8407, 8408, + 7, 11, 0, 0, 8408, 8409, 7, 6, 0, 0, 8409, 8410, 7, 3, 0, 0, 8410, 8411, + 7, 5, 0, 0, 8411, 8412, 7, 5, 0, 0, 8412, 1324, 1, 0, 0, 0, 8413, 8414, + 7, 17, 0, 0, 8414, 8415, 7, 12, 0, 0, 8415, 8416, 7, 21, 0, 0, 8416, 8417, + 7, 12, 0, 0, 8417, 8418, 7, 19, 0, 0, 8418, 8419, 7, 9, 0, 0, 8419, 8420, + 7, 12, 0, 0, 8420, 1326, 1, 0, 0, 0, 8421, 8422, 7, 17, 0, 0, 8422, 8423, + 7, 12, 0, 0, 8423, 8424, 7, 6, 0, 0, 8424, 8425, 7, 15, 0, 0, 8425, 8426, + 7, 5, 0, 0, 8426, 1328, 1, 0, 0, 0, 8427, 8428, 7, 17, 0, 0, 8428, 8429, + 7, 25, 0, 0, 8429, 8430, 7, 22, 0, 0, 8430, 8431, 7, 8, 0, 0, 8431, 8432, + 7, 3, 0, 0, 8432, 8433, 7, 4, 0, 0, 8433, 8434, 7, 7, 0, 0, 8434, 1330, + 1, 0, 0, 0, 8435, 8436, 7, 17, 0, 0, 8436, 8437, 7, 11, 0, 0, 8437, 8438, + 7, 7, 0, 0, 8438, 8439, 7, 8, 0, 0, 8439, 1332, 1, 0, 0, 0, 8440, 8441, + 7, 17, 0, 0, 8441, 8442, 7, 11, 0, 0, 8442, 8443, 7, 7, 0, 0, 8443, 8444, + 5, 95, 0, 0, 8444, 8445, 7, 18, 0, 0, 8445, 8446, 7, 8, 0, 0, 8446, 8447, + 7, 23, 0, 0, 8447, 1334, 1, 0, 0, 0, 8448, 8449, 7, 17, 0, 0, 8449, 8450, + 7, 11, 0, 0, 8450, 8451, 7, 7, 0, 0, 8451, 8452, 7, 8, 0, 0, 8452, 8453, + 5, 95, 0, 0, 8453, 8454, 7, 8, 0, 0, 8454, 8455, 7, 7, 0, 0, 8455, 8456, + 7, 11, 0, 0, 8456, 8457, 7, 19, 0, 0, 8457, 8458, 7, 17, 0, 0, 8458, 8459, + 7, 8, 0, 0, 8459, 8460, 7, 14, 0, 0, 8460, 8461, 7, 7, 0, 0, 8461, 8462, + 7, 11, 0, 0, 8462, 1336, 1, 0, 0, 0, 8463, 8464, 7, 24, 0, 0, 8464, 8465, + 7, 3, 0, 0, 8465, 8466, 7, 5, 0, 0, 8466, 8467, 7, 15, 0, 0, 8467, 8468, + 7, 4, 0, 0, 8468, 8469, 7, 3, 0, 0, 8469, 8470, 7, 6, 0, 0, 8470, 8471, + 7, 15, 0, 0, 8471, 8472, 7, 19, 0, 0, 8472, 8473, 7, 12, 0, 0, 8473, 1338, + 1, 0, 0, 0, 8474, 8475, 7, 24, 0, 0, 8475, 8476, 7, 3, 0, 0, 8476, 8477, + 7, 5, 0, 0, 8477, 8478, 7, 17, 0, 0, 8478, 8479, 7, 7, 0, 0, 8479, 1340, + 1, 0, 0, 0, 8480, 8481, 7, 24, 0, 0, 8481, 8482, 7, 3, 0, 0, 8482, 8483, + 7, 8, 0, 0, 8483, 8484, 7, 15, 0, 0, 8484, 8485, 7, 3, 0, 0, 8485, 8486, + 7, 16, 0, 0, 8486, 8487, 7, 5, 0, 0, 8487, 8488, 7, 7, 0, 0, 8488, 8489, + 7, 11, 0, 0, 8489, 1342, 1, 0, 0, 0, 8490, 8491, 7, 24, 0, 0, 8491, 8492, + 7, 15, 0, 0, 8492, 8493, 7, 7, 0, 0, 8493, 8494, 7, 9, 0, 0, 8494, 1344, + 1, 0, 0, 0, 8495, 8496, 7, 24, 0, 0, 8496, 8497, 7, 15, 0, 0, 8497, 8498, + 7, 8, 0, 0, 8498, 8499, 7, 6, 0, 0, 8499, 8500, 7, 17, 0, 0, 8500, 8501, + 7, 3, 0, 0, 8501, 8502, 7, 5, 0, 0, 8502, 1346, 1, 0, 0, 0, 8503, 8504, + 7, 24, 0, 0, 8504, 8505, 7, 15, 0, 0, 8505, 8506, 7, 11, 0, 0, 8506, 8507, + 7, 15, 0, 0, 8507, 8508, 7, 16, 0, 0, 8508, 8509, 7, 5, 0, 0, 8509, 8510, + 7, 7, 0, 0, 8510, 1348, 1, 0, 0, 0, 8511, 8512, 7, 9, 0, 0, 8512, 8513, + 7, 3, 0, 0, 8513, 8514, 7, 15, 0, 0, 8514, 8515, 7, 6, 0, 0, 8515, 1350, + 1, 0, 0, 0, 8516, 8517, 7, 9, 0, 0, 8517, 8518, 7, 3, 0, 0, 8518, 8519, + 7, 8, 0, 0, 8519, 8520, 7, 12, 0, 0, 8520, 8521, 7, 15, 0, 0, 8521, 8522, + 7, 12, 0, 0, 8522, 8523, 7, 22, 0, 0, 8523, 8524, 7, 11, 0, 0, 8524, 1352, + 1, 0, 0, 0, 8525, 8526, 7, 9, 0, 0, 8526, 8527, 7, 15, 0, 0, 8527, 8528, + 7, 12, 0, 0, 8528, 8529, 7, 4, 0, 0, 8529, 8530, 7, 19, 0, 0, 8530, 8531, + 7, 9, 0, 0, 8531, 1354, 1, 0, 0, 0, 8532, 8533, 7, 9, 0, 0, 8533, 8534, + 7, 15, 0, 0, 8534, 8535, 7, 6, 0, 0, 8535, 8536, 7, 20, 0, 0, 8536, 8537, + 7, 19, 0, 0, 8537, 8538, 7, 17, 0, 0, 8538, 8539, 7, 6, 0, 0, 8539, 1356, + 1, 0, 0, 0, 8540, 8541, 7, 9, 0, 0, 8541, 8542, 7, 19, 0, 0, 8542, 8543, + 7, 8, 0, 0, 8543, 8544, 7, 21, 0, 0, 8544, 1358, 1, 0, 0, 0, 8545, 8546, + 7, 9, 0, 0, 8546, 8547, 7, 8, 0, 0, 8547, 8548, 7, 3, 0, 0, 8548, 8549, + 7, 25, 0, 0, 8549, 8550, 7, 25, 0, 0, 8550, 8551, 7, 7, 0, 0, 8551, 8552, + 7, 8, 0, 0, 8552, 1360, 1, 0, 0, 0, 8553, 8554, 7, 26, 0, 0, 8554, 8555, + 5, 53, 0, 0, 8555, 8556, 5, 48, 0, 0, 8556, 8557, 5, 57, 0, 0, 8557, 1362, + 1, 0, 0, 0, 8558, 8559, 7, 26, 0, 0, 8559, 8560, 7, 3, 0, 0, 8560, 1364, + 1, 0, 0, 0, 8561, 8562, 7, 26, 0, 0, 8562, 8563, 7, 23, 0, 0, 8563, 8564, + 7, 5, 0, 0, 8564, 1366, 1, 0, 0, 0, 8565, 8566, 7, 10, 0, 0, 8566, 8567, + 7, 7, 0, 0, 8567, 8568, 7, 11, 0, 0, 8568, 1368, 1, 0, 0, 0, 8569, 8570, + 7, 7, 0, 0, 8570, 8571, 7, 17, 0, 0, 8571, 8572, 7, 8, 0, 0, 8572, 1370, + 1, 0, 0, 0, 8573, 8574, 7, 17, 0, 0, 8574, 8575, 7, 11, 0, 0, 8575, 8576, + 7, 3, 0, 0, 8576, 1372, 1, 0, 0, 0, 8577, 8578, 7, 27, 0, 0, 8578, 8579, + 7, 15, 0, 0, 8579, 8580, 7, 11, 0, 0, 8580, 1374, 1, 0, 0, 0, 8581, 8582, + 7, 15, 0, 0, 8582, 8583, 7, 11, 0, 0, 8583, 8584, 7, 19, 0, 0, 8584, 1376, + 1, 0, 0, 0, 8585, 8586, 7, 15, 0, 0, 8586, 8587, 7, 12, 0, 0, 8587, 8588, + 7, 6, 0, 0, 8588, 8589, 7, 7, 0, 0, 8589, 8590, 7, 8, 0, 0, 8590, 8591, + 7, 12, 0, 0, 8591, 8592, 7, 3, 0, 0, 8592, 8593, 7, 5, 0, 0, 8593, 1378, + 1, 0, 0, 0, 8594, 8595, 7, 28, 0, 0, 8595, 8596, 7, 17, 0, 0, 8596, 8597, + 7, 3, 0, 0, 8597, 8598, 7, 8, 0, 0, 8598, 8599, 7, 6, 0, 0, 8599, 8600, + 7, 7, 0, 0, 8600, 8601, 7, 8, 0, 0, 8601, 1380, 1, 0, 0, 0, 8602, 8603, + 7, 23, 0, 0, 8603, 8604, 7, 19, 0, 0, 8604, 8605, 7, 12, 0, 0, 8605, 8606, + 7, 6, 0, 0, 8606, 8607, 7, 20, 0, 0, 8607, 1382, 1, 0, 0, 0, 8608, 8609, + 7, 4, 0, 0, 8609, 8610, 7, 3, 0, 0, 8610, 8611, 7, 10, 0, 0, 8611, 1384, + 1, 0, 0, 0, 8612, 8613, 7, 20, 0, 0, 8613, 8614, 7, 19, 0, 0, 8614, 8615, + 7, 17, 0, 0, 8615, 8616, 7, 8, 0, 0, 8616, 1386, 1, 0, 0, 0, 8617, 8618, + 7, 23, 0, 0, 8618, 8619, 7, 15, 0, 0, 8619, 8620, 7, 12, 0, 0, 8620, 8621, + 7, 17, 0, 0, 8621, 8622, 7, 6, 0, 0, 8622, 8623, 7, 7, 0, 0, 8623, 1388, + 1, 0, 0, 0, 8624, 8625, 7, 9, 0, 0, 8625, 8626, 7, 7, 0, 0, 8626, 8627, + 7, 7, 0, 0, 8627, 8628, 7, 21, 0, 0, 8628, 1390, 1, 0, 0, 0, 8629, 8630, + 7, 11, 0, 0, 8630, 8631, 7, 7, 0, 0, 8631, 8632, 7, 14, 0, 0, 8632, 8633, + 7, 19, 0, 0, 8633, 8634, 7, 12, 0, 0, 8634, 8635, 7, 4, 0, 0, 8635, 1392, + 1, 0, 0, 0, 8636, 8637, 7, 23, 0, 0, 8637, 8638, 7, 15, 0, 0, 8638, 8639, + 7, 14, 0, 0, 8639, 8640, 7, 8, 0, 0, 8640, 8641, 7, 19, 0, 0, 8641, 8642, + 7, 11, 0, 0, 8642, 8643, 7, 7, 0, 0, 8643, 8644, 7, 14, 0, 0, 8644, 8645, + 7, 19, 0, 0, 8645, 8646, 7, 12, 0, 0, 8646, 8647, 7, 4, 0, 0, 8647, 1394, + 1, 0, 0, 0, 8648, 8649, 7, 3, 0, 0, 8649, 8650, 7, 4, 0, 0, 8650, 8651, + 7, 23, 0, 0, 8651, 8652, 7, 15, 0, 0, 8652, 8653, 7, 12, 0, 0, 8653, 1396, + 1, 0, 0, 0, 8654, 8655, 7, 3, 0, 0, 8655, 8656, 7, 25, 0, 0, 8656, 8657, + 7, 25, 0, 0, 8657, 8658, 7, 5, 0, 0, 8658, 8659, 7, 15, 0, 0, 8659, 8660, + 7, 14, 0, 0, 8660, 8661, 7, 3, 0, 0, 8661, 8662, 7, 6, 0, 0, 8662, 8663, + 7, 15, 0, 0, 8663, 8664, 7, 19, 0, 0, 8664, 8665, 7, 12, 0, 0, 8665, 8666, + 5, 95, 0, 0, 8666, 8667, 7, 25, 0, 0, 8667, 8668, 7, 3, 0, 0, 8668, 8669, + 7, 11, 0, 0, 8669, 8670, 7, 11, 0, 0, 8670, 8671, 7, 9, 0, 0, 8671, 8672, + 7, 19, 0, 0, 8672, 8673, 7, 8, 0, 0, 8673, 8674, 7, 4, 0, 0, 8674, 8675, + 5, 95, 0, 0, 8675, 8676, 7, 3, 0, 0, 8676, 8677, 7, 4, 0, 0, 8677, 8678, + 7, 23, 0, 0, 8678, 8679, 7, 15, 0, 0, 8679, 8680, 7, 12, 0, 0, 8680, 1398, + 1, 0, 0, 0, 8681, 8682, 7, 3, 0, 0, 8682, 8683, 7, 17, 0, 0, 8683, 8684, + 7, 4, 0, 0, 8684, 8685, 7, 15, 0, 0, 8685, 8686, 7, 6, 0, 0, 8686, 8687, + 5, 95, 0, 0, 8687, 8688, 7, 3, 0, 0, 8688, 8689, 7, 16, 0, 0, 8689, 8690, + 7, 19, 0, 0, 8690, 8691, 7, 8, 0, 0, 8691, 8692, 7, 6, 0, 0, 8692, 8693, + 5, 95, 0, 0, 8693, 8694, 7, 7, 0, 0, 8694, 8695, 7, 26, 0, 0, 8695, 8696, + 7, 7, 0, 0, 8696, 8697, 7, 23, 0, 0, 8697, 8698, 7, 25, 0, 0, 8698, 8699, + 7, 6, 0, 0, 8699, 1400, 1, 0, 0, 0, 8700, 8701, 7, 3, 0, 0, 8701, 8702, + 7, 17, 0, 0, 8702, 8703, 7, 4, 0, 0, 8703, 8704, 7, 15, 0, 0, 8704, 8705, + 7, 6, 0, 0, 8705, 8706, 5, 95, 0, 0, 8706, 8707, 7, 3, 0, 0, 8707, 8708, + 7, 4, 0, 0, 8708, 8709, 7, 23, 0, 0, 8709, 8710, 7, 15, 0, 0, 8710, 8711, + 7, 12, 0, 0, 8711, 1402, 1, 0, 0, 0, 8712, 8713, 7, 3, 0, 0, 8713, 8714, + 7, 17, 0, 0, 8714, 8715, 7, 6, 0, 0, 8715, 8716, 7, 20, 0, 0, 8716, 8717, + 7, 7, 0, 0, 8717, 8718, 7, 12, 0, 0, 8718, 8719, 7, 6, 0, 0, 8719, 8720, + 7, 15, 0, 0, 8720, 8721, 7, 14, 0, 0, 8721, 8722, 7, 3, 0, 0, 8722, 8723, + 7, 6, 0, 0, 8723, 8724, 7, 15, 0, 0, 8724, 8725, 7, 19, 0, 0, 8725, 8726, + 7, 12, 0, 0, 8726, 8727, 5, 95, 0, 0, 8727, 8728, 7, 25, 0, 0, 8728, 8729, + 7, 19, 0, 0, 8729, 8730, 7, 5, 0, 0, 8730, 8731, 7, 15, 0, 0, 8731, 8732, + 7, 14, 0, 0, 8732, 8733, 7, 10, 0, 0, 8733, 8734, 5, 95, 0, 0, 8734, 8735, + 7, 3, 0, 0, 8735, 8736, 7, 4, 0, 0, 8736, 8737, 7, 23, 0, 0, 8737, 8738, + 7, 15, 0, 0, 8738, 8739, 7, 12, 0, 0, 8739, 1404, 1, 0, 0, 0, 8740, 8741, + 7, 16, 0, 0, 8741, 8742, 7, 3, 0, 0, 8742, 8743, 7, 14, 0, 0, 8743, 8744, + 7, 21, 0, 0, 8744, 8745, 7, 17, 0, 0, 8745, 8746, 7, 25, 0, 0, 8746, 8747, + 5, 95, 0, 0, 8747, 8748, 7, 3, 0, 0, 8748, 8749, 7, 4, 0, 0, 8749, 8750, + 7, 23, 0, 0, 8750, 8751, 7, 15, 0, 0, 8751, 8752, 7, 12, 0, 0, 8752, 1406, + 1, 0, 0, 0, 8753, 8754, 7, 16, 0, 0, 8754, 8755, 7, 15, 0, 0, 8755, 8756, + 7, 12, 0, 0, 8756, 8757, 7, 5, 0, 0, 8757, 8758, 7, 19, 0, 0, 8758, 8759, + 7, 22, 0, 0, 8759, 8760, 5, 95, 0, 0, 8760, 8761, 7, 3, 0, 0, 8761, 8762, + 7, 4, 0, 0, 8762, 8763, 7, 23, 0, 0, 8763, 8764, 7, 15, 0, 0, 8764, 8765, + 7, 12, 0, 0, 8765, 1408, 1, 0, 0, 0, 8766, 8767, 7, 16, 0, 0, 8767, 8768, + 7, 15, 0, 0, 8768, 8769, 7, 12, 0, 0, 8769, 8770, 7, 5, 0, 0, 8770, 8771, + 7, 19, 0, 0, 8771, 8772, 7, 22, 0, 0, 8772, 8773, 5, 95, 0, 0, 8773, 8774, + 7, 7, 0, 0, 8774, 8775, 7, 12, 0, 0, 8775, 8776, 7, 14, 0, 0, 8776, 8777, + 7, 8, 0, 0, 8777, 8778, 7, 10, 0, 0, 8778, 8779, 7, 25, 0, 0, 8779, 8780, + 7, 6, 0, 0, 8780, 8781, 7, 15, 0, 0, 8781, 8782, 7, 19, 0, 0, 8782, 8783, + 7, 12, 0, 0, 8783, 8784, 5, 95, 0, 0, 8784, 8785, 7, 3, 0, 0, 8785, 8786, + 7, 4, 0, 0, 8786, 8787, 7, 23, 0, 0, 8787, 8788, 7, 15, 0, 0, 8788, 8789, + 7, 12, 0, 0, 8789, 1410, 1, 0, 0, 0, 8790, 8791, 7, 14, 0, 0, 8791, 8792, + 7, 5, 0, 0, 8792, 8793, 7, 19, 0, 0, 8793, 8794, 7, 12, 0, 0, 8794, 8795, + 7, 7, 0, 0, 8795, 8796, 5, 95, 0, 0, 8796, 8797, 7, 3, 0, 0, 8797, 8798, + 7, 4, 0, 0, 8798, 8799, 7, 23, 0, 0, 8799, 8800, 7, 15, 0, 0, 8800, 8801, + 7, 12, 0, 0, 8801, 1412, 1, 0, 0, 0, 8802, 8803, 7, 14, 0, 0, 8803, 8804, + 7, 19, 0, 0, 8804, 8805, 7, 12, 0, 0, 8805, 8806, 7, 12, 0, 0, 8806, 8807, + 7, 7, 0, 0, 8807, 8808, 7, 14, 0, 0, 8808, 8809, 7, 6, 0, 0, 8809, 8810, + 7, 15, 0, 0, 8810, 8811, 7, 19, 0, 0, 8811, 8812, 7, 12, 0, 0, 8812, 8813, + 5, 95, 0, 0, 8813, 8814, 7, 3, 0, 0, 8814, 8815, 7, 4, 0, 0, 8815, 8816, + 7, 23, 0, 0, 8816, 8817, 7, 15, 0, 0, 8817, 8818, 7, 12, 0, 0, 8818, 1414, + 1, 0, 0, 0, 8819, 8820, 7, 7, 0, 0, 8820, 8821, 7, 12, 0, 0, 8821, 8822, + 7, 14, 0, 0, 8822, 8823, 7, 8, 0, 0, 8823, 8824, 7, 10, 0, 0, 8824, 8825, + 7, 25, 0, 0, 8825, 8826, 7, 6, 0, 0, 8826, 8827, 7, 15, 0, 0, 8827, 8828, + 7, 19, 0, 0, 8828, 8829, 7, 12, 0, 0, 8829, 8830, 5, 95, 0, 0, 8830, 8831, + 7, 21, 0, 0, 8831, 8832, 7, 7, 0, 0, 8832, 8833, 7, 10, 0, 0, 8833, 8834, + 5, 95, 0, 0, 8834, 8835, 7, 3, 0, 0, 8835, 8836, 7, 4, 0, 0, 8836, 8837, + 7, 23, 0, 0, 8837, 8838, 7, 15, 0, 0, 8838, 8839, 7, 12, 0, 0, 8839, 1416, + 1, 0, 0, 0, 8840, 8841, 7, 7, 0, 0, 8841, 8842, 7, 26, 0, 0, 8842, 8843, + 7, 7, 0, 0, 8843, 8844, 7, 14, 0, 0, 8844, 8845, 7, 17, 0, 0, 8845, 8846, + 7, 6, 0, 0, 8846, 8847, 7, 7, 0, 0, 8847, 1418, 1, 0, 0, 0, 8848, 8849, + 7, 18, 0, 0, 8849, 8850, 7, 15, 0, 0, 8850, 8851, 7, 5, 0, 0, 8851, 8852, + 7, 7, 0, 0, 8852, 1420, 1, 0, 0, 0, 8853, 8854, 7, 18, 0, 0, 8854, 8855, + 7, 15, 0, 0, 8855, 8856, 7, 8, 0, 0, 8856, 8857, 7, 7, 0, 0, 8857, 8858, + 7, 9, 0, 0, 8858, 8859, 7, 3, 0, 0, 8859, 8860, 7, 5, 0, 0, 8860, 8861, + 7, 5, 0, 0, 8861, 8862, 5, 95, 0, 0, 8862, 8863, 7, 3, 0, 0, 8863, 8864, + 7, 4, 0, 0, 8864, 8865, 7, 23, 0, 0, 8865, 8866, 7, 15, 0, 0, 8866, 8867, + 7, 12, 0, 0, 8867, 1422, 1, 0, 0, 0, 8868, 8869, 7, 18, 0, 0, 8869, 8870, + 7, 15, 0, 0, 8870, 8871, 7, 8, 0, 0, 8871, 8872, 7, 7, 0, 0, 8872, 8873, + 7, 9, 0, 0, 8873, 8874, 7, 3, 0, 0, 8874, 8875, 7, 5, 0, 0, 8875, 8876, + 7, 5, 0, 0, 8876, 8877, 5, 95, 0, 0, 8877, 8878, 7, 7, 0, 0, 8878, 8879, + 7, 26, 0, 0, 8879, 8880, 7, 7, 0, 0, 8880, 8881, 7, 23, 0, 0, 8881, 8882, + 7, 25, 0, 0, 8882, 8883, 7, 6, 0, 0, 8883, 1424, 1, 0, 0, 0, 8884, 8885, + 7, 18, 0, 0, 8885, 8886, 7, 15, 0, 0, 8886, 8887, 7, 8, 0, 0, 8887, 8888, + 7, 7, 0, 0, 8888, 8889, 7, 9, 0, 0, 8889, 8890, 7, 3, 0, 0, 8890, 8891, + 7, 5, 0, 0, 8891, 8892, 7, 5, 0, 0, 8892, 8893, 5, 95, 0, 0, 8893, 8894, + 7, 17, 0, 0, 8894, 8895, 7, 11, 0, 0, 8895, 8896, 7, 7, 0, 0, 8896, 8897, + 7, 8, 0, 0, 8897, 1426, 1, 0, 0, 0, 8898, 8899, 7, 18, 0, 0, 8899, 8900, + 7, 5, 0, 0, 8900, 8901, 7, 17, 0, 0, 8901, 8902, 7, 11, 0, 0, 8902, 8903, + 7, 20, 0, 0, 8903, 8904, 5, 95, 0, 0, 8904, 8905, 7, 19, 0, 0, 8905, 8906, + 7, 25, 0, 0, 8906, 8907, 7, 6, 0, 0, 8907, 8908, 7, 15, 0, 0, 8908, 8909, + 7, 23, 0, 0, 8909, 8910, 7, 15, 0, 0, 8910, 8911, 7, 13, 0, 0, 8911, 8912, + 7, 7, 0, 0, 8912, 8913, 7, 8, 0, 0, 8913, 8914, 5, 95, 0, 0, 8914, 8915, + 7, 14, 0, 0, 8915, 8916, 7, 19, 0, 0, 8916, 8917, 7, 11, 0, 0, 8917, 8918, + 7, 6, 0, 0, 8918, 8919, 7, 11, 0, 0, 8919, 1428, 1, 0, 0, 0, 8920, 8921, + 7, 18, 0, 0, 8921, 8922, 7, 5, 0, 0, 8922, 8923, 7, 17, 0, 0, 8923, 8924, + 7, 11, 0, 0, 8924, 8925, 7, 20, 0, 0, 8925, 8926, 5, 95, 0, 0, 8926, 8927, + 7, 11, 0, 0, 8927, 8928, 7, 6, 0, 0, 8928, 8929, 7, 3, 0, 0, 8929, 8930, + 7, 6, 0, 0, 8930, 8931, 7, 17, 0, 0, 8931, 8932, 7, 11, 0, 0, 8932, 1430, + 1, 0, 0, 0, 8933, 8934, 7, 18, 0, 0, 8934, 8935, 7, 5, 0, 0, 8935, 8936, + 7, 17, 0, 0, 8936, 8937, 7, 11, 0, 0, 8937, 8938, 7, 20, 0, 0, 8938, 8939, + 5, 95, 0, 0, 8939, 8940, 7, 6, 0, 0, 8940, 8941, 7, 3, 0, 0, 8941, 8942, + 7, 16, 0, 0, 8942, 8943, 7, 5, 0, 0, 8943, 8944, 7, 7, 0, 0, 8944, 8945, + 7, 11, 0, 0, 8945, 1432, 1, 0, 0, 0, 8946, 8947, 7, 18, 0, 0, 8947, 8948, + 7, 5, 0, 0, 8948, 8949, 7, 17, 0, 0, 8949, 8950, 7, 11, 0, 0, 8950, 8951, + 7, 20, 0, 0, 8951, 8952, 5, 95, 0, 0, 8952, 8953, 7, 17, 0, 0, 8953, 8954, + 7, 11, 0, 0, 8954, 8955, 7, 7, 0, 0, 8955, 8956, 7, 8, 0, 0, 8956, 8957, + 5, 95, 0, 0, 8957, 8958, 7, 8, 0, 0, 8958, 8959, 7, 7, 0, 0, 8959, 8960, + 7, 11, 0, 0, 8960, 8961, 7, 19, 0, 0, 8961, 8962, 7, 17, 0, 0, 8962, 8963, + 7, 8, 0, 0, 8963, 8964, 7, 14, 0, 0, 8964, 8965, 7, 7, 0, 0, 8965, 8966, + 7, 11, 0, 0, 8966, 1434, 1, 0, 0, 0, 8967, 8968, 7, 22, 0, 0, 8968, 8969, + 7, 8, 0, 0, 8969, 8970, 7, 19, 0, 0, 8970, 8971, 7, 17, 0, 0, 8971, 8972, + 7, 25, 0, 0, 8972, 8973, 5, 95, 0, 0, 8973, 8974, 7, 8, 0, 0, 8974, 8975, + 7, 7, 0, 0, 8975, 8976, 7, 25, 0, 0, 8976, 8977, 7, 5, 0, 0, 8977, 8978, + 7, 15, 0, 0, 8978, 8979, 7, 14, 0, 0, 8979, 8980, 7, 3, 0, 0, 8980, 8981, + 7, 6, 0, 0, 8981, 8982, 7, 15, 0, 0, 8982, 8983, 7, 19, 0, 0, 8983, 8984, + 7, 12, 0, 0, 8984, 8985, 5, 95, 0, 0, 8985, 8986, 7, 3, 0, 0, 8986, 8987, + 7, 4, 0, 0, 8987, 8988, 7, 23, 0, 0, 8988, 8989, 7, 15, 0, 0, 8989, 8990, + 7, 12, 0, 0, 8990, 1436, 1, 0, 0, 0, 8991, 8992, 7, 15, 0, 0, 8992, 8993, + 7, 12, 0, 0, 8993, 8994, 7, 12, 0, 0, 8994, 8995, 7, 19, 0, 0, 8995, 8996, + 7, 4, 0, 0, 8996, 8997, 7, 16, 0, 0, 8997, 8998, 5, 95, 0, 0, 8998, 8999, + 7, 8, 0, 0, 8999, 9000, 7, 7, 0, 0, 9000, 9001, 7, 4, 0, 0, 9001, 9002, + 7, 19, 0, 0, 9002, 9003, 5, 95, 0, 0, 9003, 9004, 7, 5, 0, 0, 9004, 9005, + 7, 19, 0, 0, 9005, 9006, 7, 22, 0, 0, 9006, 9007, 5, 95, 0, 0, 9007, 9008, + 7, 3, 0, 0, 9008, 9009, 7, 8, 0, 0, 9009, 9010, 7, 14, 0, 0, 9010, 9011, + 7, 20, 0, 0, 9011, 9012, 7, 15, 0, 0, 9012, 9013, 7, 24, 0, 0, 9013, 9014, + 7, 7, 0, 0, 9014, 1438, 1, 0, 0, 0, 9015, 9016, 7, 15, 0, 0, 9016, 9017, + 7, 12, 0, 0, 9017, 9018, 7, 12, 0, 0, 9018, 9019, 7, 19, 0, 0, 9019, 9020, + 7, 4, 0, 0, 9020, 9021, 7, 16, 0, 0, 9021, 9022, 5, 95, 0, 0, 9022, 9023, + 7, 8, 0, 0, 9023, 9024, 7, 7, 0, 0, 9024, 9025, 7, 4, 0, 0, 9025, 9026, + 7, 19, 0, 0, 9026, 9027, 5, 95, 0, 0, 9027, 9028, 7, 5, 0, 0, 9028, 9029, + 7, 19, 0, 0, 9029, 9030, 7, 22, 0, 0, 9030, 9031, 5, 95, 0, 0, 9031, 9032, + 7, 7, 0, 0, 9032, 9033, 7, 12, 0, 0, 9033, 9034, 7, 3, 0, 0, 9034, 9035, + 7, 16, 0, 0, 9035, 9036, 7, 5, 0, 0, 9036, 9037, 7, 7, 0, 0, 9037, 1440, + 1, 0, 0, 0, 9038, 9039, 7, 15, 0, 0, 9039, 9040, 7, 12, 0, 0, 9040, 9041, + 7, 24, 0, 0, 9041, 9042, 7, 19, 0, 0, 9042, 9043, 7, 21, 0, 0, 9043, 9044, + 7, 7, 0, 0, 9044, 1442, 1, 0, 0, 0, 9045, 9046, 7, 5, 0, 0, 9046, 9047, + 7, 3, 0, 0, 9047, 9048, 7, 23, 0, 0, 9048, 9049, 7, 16, 0, 0, 9049, 9050, + 7, 4, 0, 0, 9050, 9051, 7, 3, 0, 0, 9051, 1444, 1, 0, 0, 0, 9052, 9053, + 7, 12, 0, 0, 9053, 9054, 7, 4, 0, 0, 9054, 9055, 7, 16, 0, 0, 9055, 9056, + 5, 95, 0, 0, 9056, 9057, 7, 11, 0, 0, 9057, 9058, 7, 6, 0, 0, 9058, 9059, + 7, 19, 0, 0, 9059, 9060, 7, 8, 0, 0, 9060, 9061, 7, 7, 0, 0, 9061, 9062, + 7, 4, 0, 0, 9062, 9063, 5, 95, 0, 0, 9063, 9064, 7, 17, 0, 0, 9064, 9065, + 7, 11, 0, 0, 9065, 9066, 7, 7, 0, 0, 9066, 9067, 7, 8, 0, 0, 9067, 1446, + 1, 0, 0, 0, 9068, 9069, 7, 25, 0, 0, 9069, 9070, 7, 3, 0, 0, 9070, 9071, + 7, 11, 0, 0, 9071, 9072, 7, 11, 0, 0, 9072, 9073, 7, 9, 0, 0, 9073, 9074, + 7, 19, 0, 0, 9074, 9075, 7, 8, 0, 0, 9075, 9076, 7, 4, 0, 0, 9076, 9077, + 7, 5, 0, 0, 9077, 9078, 7, 7, 0, 0, 9078, 9079, 7, 11, 0, 0, 9079, 9080, + 7, 11, 0, 0, 9080, 9081, 5, 95, 0, 0, 9081, 9082, 7, 17, 0, 0, 9082, 9083, + 7, 11, 0, 0, 9083, 9084, 7, 7, 0, 0, 9084, 9085, 7, 8, 0, 0, 9085, 9086, + 5, 95, 0, 0, 9086, 9087, 7, 3, 0, 0, 9087, 9088, 7, 4, 0, 0, 9088, 9089, + 7, 23, 0, 0, 9089, 9090, 7, 15, 0, 0, 9090, 9091, 7, 12, 0, 0, 9091, 1448, + 1, 0, 0, 0, 9092, 9093, 7, 25, 0, 0, 9093, 9094, 7, 7, 0, 0, 9094, 9095, + 7, 8, 0, 0, 9095, 9096, 7, 11, 0, 0, 9096, 9097, 7, 15, 0, 0, 9097, 9098, + 7, 11, 0, 0, 9098, 9099, 7, 6, 0, 0, 9099, 9100, 5, 95, 0, 0, 9100, 9101, + 7, 8, 0, 0, 9101, 9102, 7, 19, 0, 0, 9102, 9103, 5, 95, 0, 0, 9103, 9104, + 7, 24, 0, 0, 9104, 9105, 7, 3, 0, 0, 9105, 9106, 7, 8, 0, 0, 9106, 9107, + 7, 15, 0, 0, 9107, 9108, 7, 3, 0, 0, 9108, 9109, 7, 16, 0, 0, 9109, 9110, + 7, 5, 0, 0, 9110, 9111, 7, 7, 0, 0, 9111, 9112, 7, 11, 0, 0, 9112, 9113, + 5, 95, 0, 0, 9113, 9114, 7, 3, 0, 0, 9114, 9115, 7, 4, 0, 0, 9115, 9116, + 7, 23, 0, 0, 9116, 9117, 7, 15, 0, 0, 9117, 9118, 7, 12, 0, 0, 9118, 1450, + 1, 0, 0, 0, 9119, 9120, 7, 25, 0, 0, 9120, 9121, 7, 8, 0, 0, 9121, 9122, + 7, 15, 0, 0, 9122, 9123, 7, 24, 0, 0, 9123, 9124, 7, 15, 0, 0, 9124, 9125, + 7, 5, 0, 0, 9125, 9126, 7, 7, 0, 0, 9126, 9127, 7, 22, 0, 0, 9127, 9128, + 7, 7, 0, 0, 9128, 9129, 7, 11, 0, 0, 9129, 1452, 1, 0, 0, 0, 9130, 9131, + 7, 25, 0, 0, 9131, 9132, 7, 8, 0, 0, 9132, 9133, 7, 19, 0, 0, 9133, 9134, + 7, 14, 0, 0, 9134, 9135, 7, 7, 0, 0, 9135, 9136, 7, 11, 0, 0, 9136, 9137, + 7, 11, 0, 0, 9137, 1454, 1, 0, 0, 0, 9138, 9139, 7, 8, 0, 0, 9139, 9140, + 7, 7, 0, 0, 9140, 9141, 7, 5, 0, 0, 9141, 9142, 7, 19, 0, 0, 9142, 9143, + 7, 3, 0, 0, 9143, 9144, 7, 4, 0, 0, 9144, 1456, 1, 0, 0, 0, 9145, 9146, + 7, 8, 0, 0, 9146, 9147, 7, 7, 0, 0, 9147, 9148, 7, 25, 0, 0, 9148, 9149, + 7, 5, 0, 0, 9149, 9150, 7, 15, 0, 0, 9150, 9151, 7, 14, 0, 0, 9151, 9152, + 7, 3, 0, 0, 9152, 9153, 7, 6, 0, 0, 9153, 9154, 7, 15, 0, 0, 9154, 9155, + 7, 19, 0, 0, 9155, 9156, 7, 12, 0, 0, 9156, 9157, 5, 95, 0, 0, 9157, 9158, + 7, 3, 0, 0, 9158, 9159, 7, 25, 0, 0, 9159, 9160, 7, 25, 0, 0, 9160, 9161, + 7, 5, 0, 0, 9161, 9162, 7, 15, 0, 0, 9162, 9163, 7, 7, 0, 0, 9163, 9164, + 7, 8, 0, 0, 9164, 1458, 1, 0, 0, 0, 9165, 9166, 7, 8, 0, 0, 9166, 9167, + 7, 7, 0, 0, 9167, 9168, 7, 25, 0, 0, 9168, 9169, 7, 5, 0, 0, 9169, 9170, + 7, 15, 0, 0, 9170, 9171, 7, 14, 0, 0, 9171, 9172, 7, 3, 0, 0, 9172, 9173, + 7, 6, 0, 0, 9173, 9174, 7, 15, 0, 0, 9174, 9175, 7, 19, 0, 0, 9175, 9176, + 7, 12, 0, 0, 9176, 9177, 5, 95, 0, 0, 9177, 9178, 7, 11, 0, 0, 9178, 9179, + 7, 5, 0, 0, 9179, 9180, 7, 3, 0, 0, 9180, 9181, 7, 24, 0, 0, 9181, 9182, + 7, 7, 0, 0, 9182, 9183, 5, 95, 0, 0, 9183, 9184, 7, 3, 0, 0, 9184, 9185, + 7, 4, 0, 0, 9185, 9186, 7, 23, 0, 0, 9186, 9187, 7, 15, 0, 0, 9187, 9188, + 7, 12, 0, 0, 9188, 1460, 1, 0, 0, 0, 9189, 9190, 7, 8, 0, 0, 9190, 9191, + 7, 7, 0, 0, 9191, 9192, 7, 11, 0, 0, 9192, 9193, 7, 19, 0, 0, 9193, 9194, + 7, 17, 0, 0, 9194, 9195, 7, 8, 0, 0, 9195, 9196, 7, 14, 0, 0, 9196, 9197, + 7, 7, 0, 0, 9197, 9198, 5, 95, 0, 0, 9198, 9199, 7, 22, 0, 0, 9199, 9200, + 7, 8, 0, 0, 9200, 9201, 7, 19, 0, 0, 9201, 9202, 7, 17, 0, 0, 9202, 9203, + 7, 25, 0, 0, 9203, 9204, 5, 95, 0, 0, 9204, 9205, 7, 3, 0, 0, 9205, 9206, + 7, 4, 0, 0, 9206, 9207, 7, 23, 0, 0, 9207, 9208, 7, 15, 0, 0, 9208, 9209, + 7, 12, 0, 0, 9209, 1462, 1, 0, 0, 0, 9210, 9211, 7, 8, 0, 0, 9211, 9212, + 7, 7, 0, 0, 9212, 9213, 7, 11, 0, 0, 9213, 9214, 7, 19, 0, 0, 9214, 9215, + 7, 17, 0, 0, 9215, 9216, 7, 8, 0, 0, 9216, 9217, 7, 14, 0, 0, 9217, 9218, + 7, 7, 0, 0, 9218, 9219, 5, 95, 0, 0, 9219, 9220, 7, 22, 0, 0, 9220, 9221, + 7, 8, 0, 0, 9221, 9222, 7, 19, 0, 0, 9222, 9223, 7, 17, 0, 0, 9223, 9224, + 7, 25, 0, 0, 9224, 9225, 5, 95, 0, 0, 9225, 9226, 7, 17, 0, 0, 9226, 9227, + 7, 11, 0, 0, 9227, 9228, 7, 7, 0, 0, 9228, 9229, 7, 8, 0, 0, 9229, 1464, + 1, 0, 0, 0, 9230, 9231, 7, 8, 0, 0, 9231, 9232, 7, 19, 0, 0, 9232, 9233, + 7, 5, 0, 0, 9233, 9234, 7, 7, 0, 0, 9234, 9235, 5, 95, 0, 0, 9235, 9236, + 7, 3, 0, 0, 9236, 9237, 7, 4, 0, 0, 9237, 9238, 7, 23, 0, 0, 9238, 9239, + 7, 15, 0, 0, 9239, 9240, 7, 12, 0, 0, 9240, 1466, 1, 0, 0, 0, 9241, 9242, + 7, 8, 0, 0, 9242, 9243, 7, 19, 0, 0, 9243, 9244, 7, 17, 0, 0, 9244, 9245, + 7, 6, 0, 0, 9245, 9246, 7, 15, 0, 0, 9246, 9247, 7, 12, 0, 0, 9247, 9248, + 7, 7, 0, 0, 9248, 1468, 1, 0, 0, 0, 9249, 9250, 7, 11, 0, 0, 9250, 9251, + 5, 51, 0, 0, 9251, 1470, 1, 0, 0, 0, 9252, 9253, 7, 11, 0, 0, 9253, 9254, + 7, 7, 0, 0, 9254, 9255, 7, 8, 0, 0, 9255, 9256, 7, 24, 0, 0, 9256, 9257, + 7, 15, 0, 0, 9257, 9258, 7, 14, 0, 0, 9258, 9259, 7, 7, 0, 0, 9259, 9260, + 5, 95, 0, 0, 9260, 9261, 7, 14, 0, 0, 9261, 9262, 7, 19, 0, 0, 9262, 9263, + 7, 12, 0, 0, 9263, 9264, 7, 12, 0, 0, 9264, 9265, 7, 7, 0, 0, 9265, 9266, + 7, 14, 0, 0, 9266, 9267, 7, 6, 0, 0, 9267, 9268, 7, 15, 0, 0, 9268, 9269, + 7, 19, 0, 0, 9269, 9270, 7, 12, 0, 0, 9270, 9271, 5, 95, 0, 0, 9271, 9272, + 7, 3, 0, 0, 9272, 9273, 7, 4, 0, 0, 9273, 9274, 7, 23, 0, 0, 9274, 9275, + 7, 15, 0, 0, 9275, 9276, 7, 12, 0, 0, 9276, 1472, 1, 0, 0, 0, 9277, 9279, + 3, 2299, 1149, 0, 9278, 9277, 1, 0, 0, 0, 9278, 9279, 1, 0, 0, 0, 9279, + 9280, 1, 0, 0, 0, 9280, 9281, 7, 11, 0, 0, 9281, 9282, 7, 7, 0, 0, 9282, + 9283, 7, 11, 0, 0, 9283, 9284, 7, 11, 0, 0, 9284, 9285, 7, 15, 0, 0, 9285, + 9286, 7, 19, 0, 0, 9286, 9287, 7, 12, 0, 0, 9287, 9288, 5, 95, 0, 0, 9288, + 9289, 7, 24, 0, 0, 9289, 9290, 7, 3, 0, 0, 9290, 9291, 7, 8, 0, 0, 9291, + 9292, 7, 15, 0, 0, 9292, 9293, 7, 3, 0, 0, 9293, 9294, 7, 16, 0, 0, 9294, + 9295, 7, 5, 0, 0, 9295, 9296, 7, 7, 0, 0, 9296, 9297, 7, 11, 0, 0, 9297, + 9298, 5, 95, 0, 0, 9298, 9299, 7, 3, 0, 0, 9299, 9300, 7, 4, 0, 0, 9300, + 9301, 7, 23, 0, 0, 9301, 9302, 7, 15, 0, 0, 9302, 9303, 7, 12, 0, 0, 9303, + 9305, 1, 0, 0, 0, 9304, 9306, 3, 2299, 1149, 0, 9305, 9304, 1, 0, 0, 0, + 9305, 9306, 1, 0, 0, 0, 9306, 1474, 1, 0, 0, 0, 9307, 9308, 7, 11, 0, 0, + 9308, 9309, 7, 7, 0, 0, 9309, 9310, 7, 6, 0, 0, 9310, 9311, 5, 95, 0, 0, + 9311, 9312, 7, 17, 0, 0, 9312, 9313, 7, 11, 0, 0, 9313, 9314, 7, 7, 0, + 0, 9314, 9315, 7, 8, 0, 0, 9315, 9316, 5, 95, 0, 0, 9316, 9317, 7, 15, + 0, 0, 9317, 9318, 7, 4, 0, 0, 9318, 1476, 1, 0, 0, 0, 9319, 9320, 7, 11, + 0, 0, 9320, 9321, 7, 20, 0, 0, 9321, 9322, 7, 19, 0, 0, 9322, 9323, 7, + 9, 0, 0, 9323, 9324, 5, 95, 0, 0, 9324, 9325, 7, 8, 0, 0, 9325, 9326, 7, + 19, 0, 0, 9326, 9327, 7, 17, 0, 0, 9327, 9328, 7, 6, 0, 0, 9328, 9329, + 7, 15, 0, 0, 9329, 9330, 7, 12, 0, 0, 9330, 9331, 7, 7, 0, 0, 9331, 1478, + 1, 0, 0, 0, 9332, 9333, 7, 11, 0, 0, 9333, 9334, 7, 20, 0, 0, 9334, 9335, + 7, 17, 0, 0, 9335, 9336, 7, 6, 0, 0, 9336, 9337, 7, 4, 0, 0, 9337, 9338, + 7, 19, 0, 0, 9338, 9339, 7, 9, 0, 0, 9339, 9340, 7, 12, 0, 0, 9340, 1480, + 1, 0, 0, 0, 9341, 9342, 7, 11, 0, 0, 9342, 9343, 7, 17, 0, 0, 9343, 9344, + 7, 25, 0, 0, 9344, 9345, 7, 7, 0, 0, 9345, 9346, 7, 8, 0, 0, 9346, 1482, + 1, 0, 0, 0, 9347, 9348, 7, 11, 0, 0, 9348, 9349, 7, 10, 0, 0, 9349, 9350, + 7, 11, 0, 0, 9350, 9351, 7, 6, 0, 0, 9351, 9352, 7, 7, 0, 0, 9352, 9353, + 7, 23, 0, 0, 9353, 9354, 5, 95, 0, 0, 9354, 9355, 7, 24, 0, 0, 9355, 9356, + 7, 3, 0, 0, 9356, 9357, 7, 8, 0, 0, 9357, 9358, 7, 15, 0, 0, 9358, 9359, + 7, 3, 0, 0, 9359, 9360, 7, 16, 0, 0, 9360, 9361, 7, 5, 0, 0, 9361, 9362, + 7, 7, 0, 0, 9362, 9363, 7, 11, 0, 0, 9363, 9364, 5, 95, 0, 0, 9364, 9365, + 7, 3, 0, 0, 9365, 9366, 7, 4, 0, 0, 9366, 9367, 7, 23, 0, 0, 9367, 9368, + 7, 15, 0, 0, 9368, 9369, 7, 12, 0, 0, 9369, 1484, 1, 0, 0, 0, 9370, 9371, + 7, 6, 0, 0, 9371, 9372, 7, 3, 0, 0, 9372, 9373, 7, 16, 0, 0, 9373, 9374, + 7, 5, 0, 0, 9374, 9375, 7, 7, 0, 0, 9375, 9376, 7, 11, 0, 0, 9376, 1486, + 1, 0, 0, 0, 9377, 9378, 7, 6, 0, 0, 9378, 9379, 7, 3, 0, 0, 9379, 9380, + 7, 16, 0, 0, 9380, 9381, 7, 5, 0, 0, 9381, 9382, 7, 7, 0, 0, 9382, 9383, + 5, 95, 0, 0, 9383, 9384, 7, 7, 0, 0, 9384, 9385, 7, 12, 0, 0, 9385, 9386, + 7, 14, 0, 0, 9386, 9387, 7, 8, 0, 0, 9387, 9388, 7, 10, 0, 0, 9388, 9389, + 7, 25, 0, 0, 9389, 9390, 7, 6, 0, 0, 9390, 9391, 7, 15, 0, 0, 9391, 9392, + 7, 19, 0, 0, 9392, 9393, 7, 12, 0, 0, 9393, 9394, 5, 95, 0, 0, 9394, 9395, + 7, 3, 0, 0, 9395, 9396, 7, 4, 0, 0, 9396, 9397, 7, 23, 0, 0, 9397, 9398, + 7, 15, 0, 0, 9398, 9399, 7, 12, 0, 0, 9399, 1488, 1, 0, 0, 0, 9400, 9401, + 7, 24, 0, 0, 9401, 9402, 7, 7, 0, 0, 9402, 9403, 7, 8, 0, 0, 9403, 9404, + 7, 11, 0, 0, 9404, 9405, 7, 15, 0, 0, 9405, 9406, 7, 19, 0, 0, 9406, 9407, + 7, 12, 0, 0, 9407, 9408, 5, 95, 0, 0, 9408, 9409, 7, 6, 0, 0, 9409, 9410, + 7, 19, 0, 0, 9410, 9411, 7, 21, 0, 0, 9411, 9412, 7, 7, 0, 0, 9412, 9413, + 7, 12, 0, 0, 9413, 9414, 5, 95, 0, 0, 9414, 9415, 7, 3, 0, 0, 9415, 9416, + 7, 4, 0, 0, 9416, 9417, 7, 23, 0, 0, 9417, 9418, 7, 15, 0, 0, 9418, 9419, + 7, 12, 0, 0, 9419, 1490, 1, 0, 0, 0, 9420, 9421, 7, 26, 0, 0, 9421, 9422, + 7, 3, 0, 0, 9422, 9423, 5, 95, 0, 0, 9423, 9424, 7, 8, 0, 0, 9424, 9425, + 7, 7, 0, 0, 9425, 9426, 7, 14, 0, 0, 9426, 9427, 7, 19, 0, 0, 9427, 9428, + 7, 24, 0, 0, 9428, 9429, 7, 7, 0, 0, 9429, 9430, 7, 8, 0, 0, 9430, 9431, + 5, 95, 0, 0, 9431, 9432, 7, 3, 0, 0, 9432, 9433, 7, 4, 0, 0, 9433, 9434, + 7, 23, 0, 0, 9434, 9435, 7, 15, 0, 0, 9435, 9436, 7, 12, 0, 0, 9436, 1492, + 1, 0, 0, 0, 9437, 9438, 7, 3, 0, 0, 9438, 9439, 7, 8, 0, 0, 9439, 9440, + 7, 23, 0, 0, 9440, 9441, 7, 11, 0, 0, 9441, 9442, 7, 14, 0, 0, 9442, 9443, + 7, 15, 0, 0, 9443, 9444, 7, 15, 0, 0, 9444, 9445, 5, 56, 0, 0, 9445, 1494, + 1, 0, 0, 0, 9446, 9447, 7, 3, 0, 0, 9447, 9448, 7, 11, 0, 0, 9448, 9449, + 7, 14, 0, 0, 9449, 9450, 7, 15, 0, 0, 9450, 9451, 7, 15, 0, 0, 9451, 1496, + 1, 0, 0, 0, 9452, 9453, 7, 16, 0, 0, 9453, 9454, 7, 15, 0, 0, 9454, 9455, + 7, 22, 0, 0, 9455, 9456, 5, 53, 0, 0, 9456, 1498, 1, 0, 0, 0, 9457, 9458, + 7, 14, 0, 0, 9458, 9459, 7, 25, 0, 0, 9459, 9460, 5, 49, 0, 0, 9460, 9461, + 5, 50, 0, 0, 9461, 9462, 5, 53, 0, 0, 9462, 9463, 5, 48, 0, 0, 9463, 1500, + 1, 0, 0, 0, 9464, 9465, 7, 14, 0, 0, 9465, 9466, 7, 25, 0, 0, 9466, 9467, + 5, 49, 0, 0, 9467, 9468, 5, 50, 0, 0, 9468, 9469, 5, 53, 0, 0, 9469, 9470, + 5, 49, 0, 0, 9470, 1502, 1, 0, 0, 0, 9471, 9472, 7, 14, 0, 0, 9472, 9473, + 7, 25, 0, 0, 9473, 9474, 5, 49, 0, 0, 9474, 9475, 5, 50, 0, 0, 9475, 9476, + 5, 53, 0, 0, 9476, 9477, 5, 54, 0, 0, 9477, 1504, 1, 0, 0, 0, 9478, 9479, + 7, 14, 0, 0, 9479, 9480, 7, 25, 0, 0, 9480, 9481, 5, 49, 0, 0, 9481, 9482, + 5, 50, 0, 0, 9482, 9483, 5, 53, 0, 0, 9483, 9484, 5, 55, 0, 0, 9484, 1506, + 1, 0, 0, 0, 9485, 9486, 7, 14, 0, 0, 9486, 9487, 7, 25, 0, 0, 9487, 9488, + 5, 56, 0, 0, 9488, 9489, 5, 53, 0, 0, 9489, 9490, 5, 48, 0, 0, 9490, 1508, + 1, 0, 0, 0, 9491, 9492, 7, 14, 0, 0, 9492, 9493, 7, 25, 0, 0, 9493, 9494, + 5, 56, 0, 0, 9494, 9495, 5, 53, 0, 0, 9495, 9496, 5, 50, 0, 0, 9496, 1510, + 1, 0, 0, 0, 9497, 9498, 7, 14, 0, 0, 9498, 9499, 7, 25, 0, 0, 9499, 9500, + 5, 56, 0, 0, 9500, 9501, 5, 54, 0, 0, 9501, 9502, 5, 54, 0, 0, 9502, 1512, + 1, 0, 0, 0, 9503, 9504, 7, 14, 0, 0, 9504, 9505, 7, 25, 0, 0, 9505, 9506, + 5, 57, 0, 0, 9506, 9507, 5, 51, 0, 0, 9507, 9508, 5, 50, 0, 0, 9508, 1514, + 1, 0, 0, 0, 9509, 9510, 7, 4, 0, 0, 9510, 9511, 7, 7, 0, 0, 9511, 9512, + 7, 14, 0, 0, 9512, 9513, 5, 56, 0, 0, 9513, 1516, 1, 0, 0, 0, 9514, 9515, + 7, 7, 0, 0, 9515, 9516, 7, 17, 0, 0, 9516, 9517, 7, 14, 0, 0, 9517, 9518, + 7, 27, 0, 0, 9518, 9519, 7, 25, 0, 0, 9519, 9520, 7, 23, 0, 0, 9520, 9521, + 7, 11, 0, 0, 9521, 1518, 1, 0, 0, 0, 9522, 9523, 7, 7, 0, 0, 9523, 9524, + 7, 17, 0, 0, 9524, 9525, 7, 14, 0, 0, 9525, 9526, 7, 21, 0, 0, 9526, 9527, + 7, 8, 0, 0, 9527, 1520, 1, 0, 0, 0, 9528, 9529, 7, 22, 0, 0, 9529, 9530, + 7, 16, 0, 0, 9530, 9531, 5, 49, 0, 0, 9531, 9532, 5, 56, 0, 0, 9532, 9533, + 5, 48, 0, 0, 9533, 9534, 5, 51, 0, 0, 9534, 9535, 5, 48, 0, 0, 9535, 1522, + 1, 0, 0, 0, 9536, 9537, 7, 22, 0, 0, 9537, 9538, 7, 16, 0, 0, 9538, 9539, + 5, 50, 0, 0, 9539, 9540, 5, 51, 0, 0, 9540, 9541, 5, 49, 0, 0, 9541, 9542, + 5, 50, 0, 0, 9542, 1524, 1, 0, 0, 0, 9543, 9544, 7, 22, 0, 0, 9544, 9545, + 7, 16, 0, 0, 9545, 9546, 7, 21, 0, 0, 9546, 1526, 1, 0, 0, 0, 9547, 9548, + 7, 22, 0, 0, 9548, 9549, 7, 7, 0, 0, 9549, 9550, 7, 19, 0, 0, 9550, 9551, + 7, 11, 0, 0, 9551, 9552, 7, 6, 0, 0, 9552, 9553, 7, 4, 0, 0, 9553, 9554, + 5, 56, 0, 0, 9554, 1528, 1, 0, 0, 0, 9555, 9556, 7, 22, 0, 0, 9556, 9557, + 7, 8, 0, 0, 9557, 9558, 7, 7, 0, 0, 9558, 9559, 7, 7, 0, 0, 9559, 9560, + 7, 21, 0, 0, 9560, 1530, 1, 0, 0, 0, 9561, 9562, 7, 20, 0, 0, 9562, 9563, + 7, 7, 0, 0, 9563, 9564, 7, 16, 0, 0, 9564, 9565, 7, 8, 0, 0, 9565, 9566, + 7, 7, 0, 0, 9566, 9567, 7, 9, 0, 0, 9567, 1532, 1, 0, 0, 0, 9568, 9569, + 7, 20, 0, 0, 9569, 9570, 7, 25, 0, 0, 9570, 9571, 5, 56, 0, 0, 9571, 1534, + 1, 0, 0, 0, 9572, 9573, 7, 21, 0, 0, 9573, 9574, 7, 7, 0, 0, 9574, 9575, + 7, 10, 0, 0, 9575, 9576, 7, 16, 0, 0, 9576, 9577, 7, 14, 0, 0, 9577, 9578, + 7, 11, 0, 0, 9578, 9579, 5, 50, 0, 0, 9579, 1536, 1, 0, 0, 0, 9580, 9581, + 7, 21, 0, 0, 9581, 9582, 7, 19, 0, 0, 9582, 9583, 7, 15, 0, 0, 9583, 9584, + 5, 56, 0, 0, 9584, 9585, 7, 8, 0, 0, 9585, 1538, 1, 0, 0, 0, 9586, 9587, + 7, 21, 0, 0, 9587, 9588, 7, 19, 0, 0, 9588, 9589, 7, 15, 0, 0, 9589, 9590, + 5, 56, 0, 0, 9590, 9591, 7, 17, 0, 0, 9591, 1540, 1, 0, 0, 0, 9592, 9593, + 7, 5, 0, 0, 9593, 9594, 7, 3, 0, 0, 9594, 9595, 7, 6, 0, 0, 9595, 9596, + 7, 15, 0, 0, 9596, 9597, 7, 12, 0, 0, 9597, 9598, 5, 49, 0, 0, 9598, 1542, + 1, 0, 0, 0, 9599, 9600, 7, 5, 0, 0, 9600, 9601, 7, 3, 0, 0, 9601, 9602, + 7, 6, 0, 0, 9602, 9603, 7, 15, 0, 0, 9603, 9604, 7, 12, 0, 0, 9604, 9605, + 5, 50, 0, 0, 9605, 1544, 1, 0, 0, 0, 9606, 9607, 7, 5, 0, 0, 9607, 9608, + 7, 3, 0, 0, 9608, 9609, 7, 6, 0, 0, 9609, 9610, 7, 15, 0, 0, 9610, 9611, + 7, 12, 0, 0, 9611, 9612, 5, 53, 0, 0, 9612, 1546, 1, 0, 0, 0, 9613, 9614, + 7, 5, 0, 0, 9614, 9615, 7, 3, 0, 0, 9615, 9616, 7, 6, 0, 0, 9616, 9617, + 7, 15, 0, 0, 9617, 9618, 7, 12, 0, 0, 9618, 9619, 5, 55, 0, 0, 9619, 1548, + 1, 0, 0, 0, 9620, 9621, 7, 23, 0, 0, 9621, 9622, 7, 3, 0, 0, 9622, 9623, + 7, 14, 0, 0, 9623, 9624, 7, 14, 0, 0, 9624, 9625, 7, 7, 0, 0, 9625, 1550, + 1, 0, 0, 0, 9626, 9627, 7, 23, 0, 0, 9627, 9628, 7, 3, 0, 0, 9628, 9629, + 7, 14, 0, 0, 9629, 9630, 7, 8, 0, 0, 9630, 9631, 7, 19, 0, 0, 9631, 9632, + 7, 23, 0, 0, 9632, 9633, 7, 3, 0, 0, 9633, 9634, 7, 12, 0, 0, 9634, 1552, + 1, 0, 0, 0, 9635, 9636, 7, 11, 0, 0, 9636, 9637, 7, 27, 0, 0, 9637, 9638, + 7, 15, 0, 0, 9638, 9639, 7, 11, 0, 0, 9639, 1554, 1, 0, 0, 0, 9640, 9641, + 7, 11, 0, 0, 9641, 9642, 7, 9, 0, 0, 9642, 9643, 7, 7, 0, 0, 9643, 9644, + 5, 55, 0, 0, 9644, 1556, 1, 0, 0, 0, 9645, 9646, 7, 6, 0, 0, 9646, 9647, + 7, 15, 0, 0, 9647, 9648, 7, 11, 0, 0, 9648, 9649, 5, 54, 0, 0, 9649, 9650, + 5, 50, 0, 0, 9650, 9651, 5, 48, 0, 0, 9651, 1558, 1, 0, 0, 0, 9652, 9653, + 7, 17, 0, 0, 9653, 9654, 7, 14, 0, 0, 9654, 9655, 7, 11, 0, 0, 9655, 9656, + 5, 50, 0, 0, 9656, 1560, 1, 0, 0, 0, 9657, 9658, 7, 17, 0, 0, 9658, 9659, + 7, 27, 0, 0, 9659, 9660, 7, 15, 0, 0, 9660, 9661, 7, 11, 0, 0, 9661, 1562, + 1, 0, 0, 0, 9662, 9663, 7, 17, 0, 0, 9663, 9664, 7, 6, 0, 0, 9664, 9665, + 7, 18, 0, 0, 9665, 9666, 5, 49, 0, 0, 9666, 9667, 5, 54, 0, 0, 9667, 1564, + 1, 0, 0, 0, 9668, 9669, 7, 17, 0, 0, 9669, 9670, 7, 6, 0, 0, 9670, 9671, + 7, 18, 0, 0, 9671, 9672, 5, 49, 0, 0, 9672, 9673, 5, 54, 0, 0, 9673, 9674, + 7, 5, 0, 0, 9674, 9675, 7, 7, 0, 0, 9675, 1566, 1, 0, 0, 0, 9676, 9677, + 7, 17, 0, 0, 9677, 9678, 7, 6, 0, 0, 9678, 9679, 7, 18, 0, 0, 9679, 9680, + 5, 51, 0, 0, 9680, 9681, 5, 50, 0, 0, 9681, 1568, 1, 0, 0, 0, 9682, 9683, + 7, 17, 0, 0, 9683, 9684, 7, 6, 0, 0, 9684, 9685, 7, 18, 0, 0, 9685, 9686, + 5, 56, 0, 0, 9686, 1570, 1, 0, 0, 0, 9687, 9688, 7, 17, 0, 0, 9688, 9689, + 7, 6, 0, 0, 9689, 9690, 7, 18, 0, 0, 9690, 9691, 5, 56, 0, 0, 9691, 9692, + 7, 23, 0, 0, 9692, 9693, 7, 16, 0, 0, 9693, 9694, 5, 51, 0, 0, 9694, 1572, + 1, 0, 0, 0, 9695, 9696, 7, 17, 0, 0, 9696, 9697, 7, 6, 0, 0, 9697, 9698, + 7, 18, 0, 0, 9698, 9699, 5, 56, 0, 0, 9699, 9700, 7, 23, 0, 0, 9700, 9701, + 7, 16, 0, 0, 9701, 9702, 5, 52, 0, 0, 9702, 1574, 1, 0, 0, 0, 9703, 9704, + 7, 3, 0, 0, 9704, 9705, 7, 8, 0, 0, 9705, 9706, 7, 14, 0, 0, 9706, 9707, + 7, 20, 0, 0, 9707, 9708, 7, 15, 0, 0, 9708, 9709, 7, 24, 0, 0, 9709, 9710, + 7, 7, 0, 0, 9710, 1576, 1, 0, 0, 0, 9711, 9712, 7, 16, 0, 0, 9712, 9713, + 7, 5, 0, 0, 9713, 9714, 7, 3, 0, 0, 9714, 9715, 7, 14, 0, 0, 9715, 9716, + 7, 21, 0, 0, 9716, 9717, 7, 20, 0, 0, 9717, 9718, 7, 19, 0, 0, 9718, 9719, + 7, 5, 0, 0, 9719, 9720, 7, 7, 0, 0, 9720, 1578, 1, 0, 0, 0, 9721, 9722, + 7, 14, 0, 0, 9722, 9723, 7, 11, 0, 0, 9723, 9724, 7, 24, 0, 0, 9724, 1580, + 1, 0, 0, 0, 9725, 9726, 7, 18, 0, 0, 9726, 9727, 7, 7, 0, 0, 9727, 9728, + 7, 4, 0, 0, 9728, 9729, 7, 7, 0, 0, 9729, 9730, 7, 8, 0, 0, 9730, 9731, + 7, 3, 0, 0, 9731, 9732, 7, 6, 0, 0, 9732, 9733, 7, 7, 0, 0, 9733, 9734, + 7, 4, 0, 0, 9734, 1582, 1, 0, 0, 0, 9735, 9736, 7, 15, 0, 0, 9736, 9737, + 7, 12, 0, 0, 9737, 9738, 7, 12, 0, 0, 9738, 9739, 7, 19, 0, 0, 9739, 9740, + 7, 4, 0, 0, 9740, 9741, 7, 16, 0, 0, 9741, 1584, 1, 0, 0, 0, 9742, 9743, + 7, 23, 0, 0, 9743, 9744, 7, 7, 0, 0, 9744, 9745, 7, 23, 0, 0, 9745, 9746, + 7, 19, 0, 0, 9746, 9747, 7, 8, 0, 0, 9747, 9748, 7, 10, 0, 0, 9748, 1586, + 1, 0, 0, 0, 9749, 9750, 7, 23, 0, 0, 9750, 9751, 7, 8, 0, 0, 9751, 9752, + 7, 22, 0, 0, 9752, 9753, 5, 95, 0, 0, 9753, 9754, 7, 23, 0, 0, 9754, 9755, + 7, 10, 0, 0, 9755, 9756, 7, 15, 0, 0, 9756, 9757, 7, 11, 0, 0, 9757, 9758, + 7, 3, 0, 0, 9758, 9759, 7, 23, 0, 0, 9759, 1588, 1, 0, 0, 0, 9760, 9761, + 7, 23, 0, 0, 9761, 9762, 7, 10, 0, 0, 9762, 9763, 7, 15, 0, 0, 9763, 9764, + 7, 11, 0, 0, 9764, 9765, 7, 3, 0, 0, 9765, 9766, 7, 23, 0, 0, 9766, 1590, + 1, 0, 0, 0, 9767, 9768, 7, 12, 0, 0, 9768, 9769, 7, 4, 0, 0, 9769, 9770, + 7, 16, 0, 0, 9770, 1592, 1, 0, 0, 0, 9771, 9772, 7, 12, 0, 0, 9772, 9773, + 7, 4, 0, 0, 9773, 9774, 7, 16, 0, 0, 9774, 9775, 7, 14, 0, 0, 9775, 9776, + 7, 5, 0, 0, 9776, 9777, 7, 17, 0, 0, 9777, 9778, 7, 11, 0, 0, 9778, 9779, + 7, 6, 0, 0, 9779, 9780, 7, 7, 0, 0, 9780, 9781, 7, 8, 0, 0, 9781, 1594, + 1, 0, 0, 0, 9782, 9783, 7, 25, 0, 0, 9783, 9784, 7, 7, 0, 0, 9784, 9785, + 7, 8, 0, 0, 9785, 9786, 7, 18, 0, 0, 9786, 9787, 7, 19, 0, 0, 9787, 9788, + 7, 8, 0, 0, 9788, 9789, 7, 23, 0, 0, 9789, 9790, 7, 3, 0, 0, 9790, 9791, + 7, 12, 0, 0, 9791, 9792, 7, 14, 0, 0, 9792, 9793, 7, 7, 0, 0, 9793, 9794, + 5, 95, 0, 0, 9794, 9795, 7, 11, 0, 0, 9795, 9796, 7, 14, 0, 0, 9796, 9797, + 7, 20, 0, 0, 9797, 9798, 7, 7, 0, 0, 9798, 9799, 7, 23, 0, 0, 9799, 9800, + 7, 3, 0, 0, 9800, 1596, 1, 0, 0, 0, 9801, 9802, 7, 6, 0, 0, 9802, 9803, + 7, 19, 0, 0, 9803, 9804, 7, 21, 0, 0, 9804, 9805, 7, 17, 0, 0, 9805, 9806, + 7, 4, 0, 0, 9806, 9807, 7, 16, 0, 0, 9807, 1598, 1, 0, 0, 0, 9808, 9809, + 7, 8, 0, 0, 9809, 9810, 7, 7, 0, 0, 9810, 9811, 7, 25, 0, 0, 9811, 9812, + 7, 7, 0, 0, 9812, 9813, 7, 3, 0, 0, 9813, 9814, 7, 6, 0, 0, 9814, 9815, + 7, 3, 0, 0, 9815, 9816, 7, 16, 0, 0, 9816, 9817, 7, 5, 0, 0, 9817, 9818, + 7, 7, 0, 0, 9818, 1600, 1, 0, 0, 0, 9819, 9820, 7, 14, 0, 0, 9820, 9821, + 7, 19, 0, 0, 9821, 9822, 7, 23, 0, 0, 9822, 9823, 7, 23, 0, 0, 9823, 9824, + 7, 15, 0, 0, 9824, 9825, 7, 6, 0, 0, 9825, 9826, 7, 6, 0, 0, 9826, 9827, + 7, 7, 0, 0, 9827, 9828, 7, 4, 0, 0, 9828, 1602, 1, 0, 0, 0, 9829, 9830, + 7, 17, 0, 0, 9830, 9831, 7, 12, 0, 0, 9831, 9832, 7, 14, 0, 0, 9832, 9833, + 7, 19, 0, 0, 9833, 9834, 7, 23, 0, 0, 9834, 9835, 7, 23, 0, 0, 9835, 9836, + 7, 15, 0, 0, 9836, 9837, 7, 6, 0, 0, 9837, 9838, 7, 6, 0, 0, 9838, 9839, + 7, 7, 0, 0, 9839, 9840, 7, 4, 0, 0, 9840, 1604, 1, 0, 0, 0, 9841, 9842, + 7, 11, 0, 0, 9842, 9843, 7, 7, 0, 0, 9843, 9844, 7, 8, 0, 0, 9844, 9845, + 7, 15, 0, 0, 9845, 9846, 7, 3, 0, 0, 9846, 9847, 7, 5, 0, 0, 9847, 9848, + 7, 15, 0, 0, 9848, 9849, 7, 13, 0, 0, 9849, 9850, 7, 3, 0, 0, 9850, 9851, + 7, 16, 0, 0, 9851, 9852, 7, 5, 0, 0, 9852, 9853, 7, 7, 0, 0, 9853, 1606, + 1, 0, 0, 0, 9854, 9855, 7, 22, 0, 0, 9855, 9856, 7, 7, 0, 0, 9856, 9857, + 7, 19, 0, 0, 9857, 9858, 7, 23, 0, 0, 9858, 9859, 7, 7, 0, 0, 9859, 9860, + 7, 6, 0, 0, 9860, 9861, 7, 8, 0, 0, 9861, 9862, 7, 10, 0, 0, 9862, 9863, + 7, 14, 0, 0, 9863, 9864, 7, 19, 0, 0, 9864, 9865, 7, 5, 0, 0, 9865, 9866, + 7, 5, 0, 0, 9866, 9867, 7, 7, 0, 0, 9867, 9868, 7, 14, 0, 0, 9868, 9869, + 7, 6, 0, 0, 9869, 9870, 7, 15, 0, 0, 9870, 9871, 7, 19, 0, 0, 9871, 9872, + 7, 12, 0, 0, 9872, 1608, 1, 0, 0, 0, 9873, 9874, 7, 22, 0, 0, 9874, 9875, + 7, 7, 0, 0, 9875, 9876, 7, 19, 0, 0, 9876, 9877, 7, 23, 0, 0, 9877, 9878, + 7, 14, 0, 0, 9878, 9879, 7, 19, 0, 0, 9879, 9880, 7, 5, 0, 0, 9880, 9881, + 7, 5, 0, 0, 9881, 9882, 7, 7, 0, 0, 9882, 9883, 7, 14, 0, 0, 9883, 9884, + 7, 6, 0, 0, 9884, 9885, 7, 15, 0, 0, 9885, 9886, 7, 19, 0, 0, 9886, 9887, + 7, 12, 0, 0, 9887, 1610, 1, 0, 0, 0, 9888, 9889, 7, 22, 0, 0, 9889, 9890, + 7, 7, 0, 0, 9890, 9891, 7, 19, 0, 0, 9891, 9892, 7, 23, 0, 0, 9892, 9893, + 7, 7, 0, 0, 9893, 9894, 7, 6, 0, 0, 9894, 9895, 7, 8, 0, 0, 9895, 9896, + 7, 10, 0, 0, 9896, 1612, 1, 0, 0, 0, 9897, 9898, 7, 5, 0, 0, 9898, 9899, + 7, 15, 0, 0, 9899, 9900, 7, 12, 0, 0, 9900, 9901, 7, 7, 0, 0, 9901, 9902, + 7, 11, 0, 0, 9902, 9903, 7, 6, 0, 0, 9903, 9904, 7, 8, 0, 0, 9904, 9905, + 7, 15, 0, 0, 9905, 9906, 7, 12, 0, 0, 9906, 9907, 7, 22, 0, 0, 9907, 1614, + 1, 0, 0, 0, 9908, 9909, 7, 23, 0, 0, 9909, 9910, 7, 17, 0, 0, 9910, 9911, + 7, 5, 0, 0, 9911, 9912, 7, 6, 0, 0, 9912, 9913, 7, 15, 0, 0, 9913, 9914, + 7, 5, 0, 0, 9914, 9915, 7, 15, 0, 0, 9915, 9916, 7, 12, 0, 0, 9916, 9917, + 7, 7, 0, 0, 9917, 9918, 7, 11, 0, 0, 9918, 9919, 7, 6, 0, 0, 9919, 9920, + 7, 8, 0, 0, 9920, 9921, 7, 15, 0, 0, 9921, 9922, 7, 12, 0, 0, 9922, 9923, + 7, 22, 0, 0, 9923, 1616, 1, 0, 0, 0, 9924, 9925, 7, 23, 0, 0, 9925, 9926, + 7, 17, 0, 0, 9926, 9927, 7, 5, 0, 0, 9927, 9928, 7, 6, 0, 0, 9928, 9929, + 7, 15, 0, 0, 9929, 9930, 7, 25, 0, 0, 9930, 9931, 7, 19, 0, 0, 9931, 9932, + 7, 15, 0, 0, 9932, 9933, 7, 12, 0, 0, 9933, 9934, 7, 6, 0, 0, 9934, 1618, + 1, 0, 0, 0, 9935, 9936, 7, 23, 0, 0, 9936, 9937, 7, 17, 0, 0, 9937, 9938, + 7, 5, 0, 0, 9938, 9939, 7, 6, 0, 0, 9939, 9940, 7, 15, 0, 0, 9940, 9941, + 7, 25, 0, 0, 9941, 9942, 7, 19, 0, 0, 9942, 9943, 7, 5, 0, 0, 9943, 9944, + 7, 10, 0, 0, 9944, 9945, 7, 22, 0, 0, 9945, 9946, 7, 19, 0, 0, 9946, 9947, + 7, 12, 0, 0, 9947, 1620, 1, 0, 0, 0, 9948, 9949, 7, 25, 0, 0, 9949, 9950, + 7, 19, 0, 0, 9950, 9951, 7, 15, 0, 0, 9951, 9952, 7, 12, 0, 0, 9952, 9953, + 7, 6, 0, 0, 9953, 1622, 1, 0, 0, 0, 9954, 9955, 7, 25, 0, 0, 9955, 9956, + 7, 19, 0, 0, 9956, 9957, 7, 5, 0, 0, 9957, 9958, 7, 10, 0, 0, 9958, 9959, + 7, 22, 0, 0, 9959, 9960, 7, 19, 0, 0, 9960, 9961, 7, 12, 0, 0, 9961, 1624, + 1, 0, 0, 0, 9962, 9963, 7, 3, 0, 0, 9963, 9964, 7, 16, 0, 0, 9964, 9965, + 7, 11, 0, 0, 9965, 1626, 1, 0, 0, 0, 9966, 9967, 7, 3, 0, 0, 9967, 9968, + 7, 14, 0, 0, 9968, 9969, 7, 19, 0, 0, 9969, 9970, 7, 11, 0, 0, 9970, 1628, + 1, 0, 0, 0, 9971, 9972, 7, 3, 0, 0, 9972, 9973, 7, 4, 0, 0, 9973, 9974, + 7, 4, 0, 0, 9974, 9975, 7, 4, 0, 0, 9975, 9976, 7, 3, 0, 0, 9976, 9977, + 7, 6, 0, 0, 9977, 9978, 7, 7, 0, 0, 9978, 1630, 1, 0, 0, 0, 9979, 9980, + 7, 3, 0, 0, 9980, 9981, 7, 4, 0, 0, 9981, 9982, 7, 4, 0, 0, 9982, 9983, + 7, 6, 0, 0, 9983, 9984, 7, 15, 0, 0, 9984, 9985, 7, 23, 0, 0, 9985, 9986, + 7, 7, 0, 0, 9986, 1632, 1, 0, 0, 0, 9987, 9988, 7, 3, 0, 0, 9988, 9989, + 7, 7, 0, 0, 9989, 9990, 7, 11, 0, 0, 9990, 9991, 5, 95, 0, 0, 9991, 9992, + 7, 4, 0, 0, 9992, 9993, 7, 7, 0, 0, 9993, 9994, 7, 14, 0, 0, 9994, 9995, + 7, 8, 0, 0, 9995, 9996, 7, 10, 0, 0, 9996, 9997, 7, 25, 0, 0, 9997, 9998, + 7, 6, 0, 0, 9998, 1634, 1, 0, 0, 0, 9999, 10000, 7, 3, 0, 0, 10000, 10001, + 7, 7, 0, 0, 10001, 10002, 7, 11, 0, 0, 10002, 10003, 5, 95, 0, 0, 10003, + 10004, 7, 7, 0, 0, 10004, 10005, 7, 12, 0, 0, 10005, 10006, 7, 14, 0, 0, + 10006, 10007, 7, 8, 0, 0, 10007, 10008, 7, 10, 0, 0, 10008, 10009, 7, 25, + 0, 0, 10009, 10010, 7, 6, 0, 0, 10010, 1636, 1, 0, 0, 0, 10011, 10012, + 7, 3, 0, 0, 10012, 10013, 7, 8, 0, 0, 10013, 10014, 7, 7, 0, 0, 10014, + 10015, 7, 3, 0, 0, 10015, 1638, 1, 0, 0, 0, 10016, 10017, 7, 3, 0, 0, 10017, + 10018, 7, 11, 0, 0, 10018, 10019, 7, 16, 0, 0, 10019, 10020, 7, 15, 0, + 0, 10020, 10021, 7, 12, 0, 0, 10021, 10022, 7, 3, 0, 0, 10022, 10023, 7, + 8, 0, 0, 10023, 10024, 7, 10, 0, 0, 10024, 1640, 1, 0, 0, 0, 10025, 10026, + 7, 3, 0, 0, 10026, 10027, 7, 11, 0, 0, 10027, 10028, 7, 15, 0, 0, 10028, + 10029, 7, 12, 0, 0, 10029, 1642, 1, 0, 0, 0, 10030, 10031, 7, 3, 0, 0, + 10031, 10032, 7, 11, 0, 0, 10032, 10033, 7, 6, 0, 0, 10033, 10034, 7, 7, + 0, 0, 10034, 10035, 7, 26, 0, 0, 10035, 10036, 7, 6, 0, 0, 10036, 1644, + 1, 0, 0, 0, 10037, 10038, 7, 3, 0, 0, 10038, 10039, 7, 11, 0, 0, 10039, + 10040, 7, 9, 0, 0, 10040, 10041, 7, 21, 0, 0, 10041, 10042, 7, 16, 0, 0, + 10042, 1646, 1, 0, 0, 0, 10043, 10044, 7, 3, 0, 0, 10044, 10045, 7, 11, + 0, 0, 10045, 10046, 7, 9, 0, 0, 10046, 10047, 7, 21, 0, 0, 10047, 10048, + 7, 6, 0, 0, 10048, 1648, 1, 0, 0, 0, 10049, 10050, 7, 3, 0, 0, 10050, 10051, + 7, 11, 0, 0, 10051, 10052, 7, 10, 0, 0, 10052, 10053, 7, 23, 0, 0, 10053, + 10054, 7, 23, 0, 0, 10054, 10055, 7, 7, 0, 0, 10055, 10056, 7, 6, 0, 0, + 10056, 10057, 7, 8, 0, 0, 10057, 10058, 7, 15, 0, 0, 10058, 10059, 7, 14, + 0, 0, 10059, 10060, 5, 95, 0, 0, 10060, 10061, 7, 4, 0, 0, 10061, 10062, + 7, 7, 0, 0, 10062, 10063, 7, 14, 0, 0, 10063, 10064, 7, 8, 0, 0, 10064, + 10065, 7, 10, 0, 0, 10065, 10066, 7, 25, 0, 0, 10066, 10067, 7, 6, 0, 0, + 10067, 1650, 1, 0, 0, 0, 10068, 10069, 7, 3, 0, 0, 10069, 10070, 7, 11, + 0, 0, 10070, 10071, 7, 10, 0, 0, 10071, 10072, 7, 23, 0, 0, 10072, 10073, + 7, 23, 0, 0, 10073, 10074, 7, 7, 0, 0, 10074, 10075, 7, 6, 0, 0, 10075, + 10076, 7, 8, 0, 0, 10076, 10077, 7, 15, 0, 0, 10077, 10078, 7, 14, 0, 0, + 10078, 10079, 5, 95, 0, 0, 10079, 10080, 7, 4, 0, 0, 10080, 10081, 7, 7, + 0, 0, 10081, 10082, 7, 8, 0, 0, 10082, 10083, 7, 15, 0, 0, 10083, 10084, + 7, 24, 0, 0, 10084, 10085, 7, 7, 0, 0, 10085, 1652, 1, 0, 0, 0, 10086, + 10087, 7, 3, 0, 0, 10087, 10088, 7, 11, 0, 0, 10088, 10089, 7, 10, 0, 0, + 10089, 10090, 7, 23, 0, 0, 10090, 10091, 7, 23, 0, 0, 10091, 10092, 7, + 7, 0, 0, 10092, 10093, 7, 6, 0, 0, 10093, 10094, 7, 8, 0, 0, 10094, 10095, + 7, 15, 0, 0, 10095, 10096, 7, 14, 0, 0, 10096, 10097, 5, 95, 0, 0, 10097, + 10098, 7, 7, 0, 0, 10098, 10099, 7, 12, 0, 0, 10099, 10100, 7, 14, 0, 0, + 10100, 10101, 7, 8, 0, 0, 10101, 10102, 7, 10, 0, 0, 10102, 10103, 7, 25, + 0, 0, 10103, 10104, 7, 6, 0, 0, 10104, 1654, 1, 0, 0, 0, 10105, 10106, + 7, 3, 0, 0, 10106, 10107, 7, 11, 0, 0, 10107, 10108, 7, 10, 0, 0, 10108, + 10109, 7, 23, 0, 0, 10109, 10110, 7, 23, 0, 0, 10110, 10111, 7, 7, 0, 0, + 10111, 10112, 7, 6, 0, 0, 10112, 10113, 7, 8, 0, 0, 10113, 10114, 7, 15, + 0, 0, 10114, 10115, 7, 14, 0, 0, 10115, 10116, 5, 95, 0, 0, 10116, 10117, + 7, 11, 0, 0, 10117, 10118, 7, 15, 0, 0, 10118, 10119, 7, 22, 0, 0, 10119, + 10120, 7, 12, 0, 0, 10120, 1656, 1, 0, 0, 0, 10121, 10122, 7, 3, 0, 0, + 10122, 10123, 7, 11, 0, 0, 10123, 10124, 7, 10, 0, 0, 10124, 10125, 7, + 23, 0, 0, 10125, 10126, 7, 23, 0, 0, 10126, 10127, 7, 7, 0, 0, 10127, 10128, + 7, 6, 0, 0, 10128, 10129, 7, 8, 0, 0, 10129, 10130, 7, 15, 0, 0, 10130, + 10131, 7, 14, 0, 0, 10131, 10132, 5, 95, 0, 0, 10132, 10133, 7, 24, 0, + 0, 10133, 10134, 7, 7, 0, 0, 10134, 10135, 7, 8, 0, 0, 10135, 10136, 7, + 15, 0, 0, 10136, 10137, 7, 18, 0, 0, 10137, 10138, 7, 10, 0, 0, 10138, + 1658, 1, 0, 0, 0, 10139, 10140, 7, 3, 0, 0, 10140, 10141, 7, 6, 0, 0, 10141, + 10142, 7, 3, 0, 0, 10142, 10143, 7, 12, 0, 0, 10143, 1660, 1, 0, 0, 0, + 10144, 10145, 7, 3, 0, 0, 10145, 10146, 7, 6, 0, 0, 10146, 10147, 7, 3, + 0, 0, 10147, 10148, 7, 12, 0, 0, 10148, 10149, 5, 50, 0, 0, 10149, 1662, + 1, 0, 0, 0, 10150, 10151, 7, 16, 0, 0, 10151, 10152, 7, 7, 0, 0, 10152, + 10153, 7, 12, 0, 0, 10153, 10154, 7, 14, 0, 0, 10154, 10155, 7, 20, 0, + 0, 10155, 10156, 7, 23, 0, 0, 10156, 10157, 7, 3, 0, 0, 10157, 10158, 7, + 8, 0, 0, 10158, 10159, 7, 21, 0, 0, 10159, 1664, 1, 0, 0, 0, 10160, 10161, + 7, 16, 0, 0, 10161, 10162, 7, 15, 0, 0, 10162, 10163, 7, 12, 0, 0, 10163, + 1666, 1, 0, 0, 0, 10164, 10165, 7, 16, 0, 0, 10165, 10166, 7, 15, 0, 0, + 10166, 10167, 7, 6, 0, 0, 10167, 10168, 5, 95, 0, 0, 10168, 10169, 7, 14, + 0, 0, 10169, 10170, 7, 19, 0, 0, 10170, 10171, 7, 17, 0, 0, 10171, 10172, + 7, 12, 0, 0, 10172, 10173, 7, 6, 0, 0, 10173, 1668, 1, 0, 0, 0, 10174, + 10175, 7, 16, 0, 0, 10175, 10176, 7, 15, 0, 0, 10176, 10177, 7, 6, 0, 0, + 10177, 10178, 5, 95, 0, 0, 10178, 10179, 7, 5, 0, 0, 10179, 10180, 7, 7, + 0, 0, 10180, 10181, 7, 12, 0, 0, 10181, 10182, 7, 22, 0, 0, 10182, 10183, + 7, 6, 0, 0, 10183, 10184, 7, 20, 0, 0, 10184, 1670, 1, 0, 0, 0, 10185, + 10186, 7, 16, 0, 0, 10186, 10187, 7, 17, 0, 0, 10187, 10188, 7, 18, 0, + 0, 10188, 10189, 7, 18, 0, 0, 10189, 10190, 7, 7, 0, 0, 10190, 10191, 7, + 8, 0, 0, 10191, 1672, 1, 0, 0, 0, 10192, 10193, 7, 14, 0, 0, 10193, 10194, + 7, 3, 0, 0, 10194, 10195, 7, 6, 0, 0, 10195, 10196, 7, 3, 0, 0, 10196, + 10197, 7, 5, 0, 0, 10197, 10198, 7, 19, 0, 0, 10198, 10199, 7, 22, 0, 0, + 10199, 10200, 5, 95, 0, 0, 10200, 10201, 7, 12, 0, 0, 10201, 10202, 7, + 3, 0, 0, 10202, 10203, 7, 23, 0, 0, 10203, 10204, 7, 7, 0, 0, 10204, 1674, + 1, 0, 0, 0, 10205, 10206, 7, 14, 0, 0, 10206, 10207, 7, 7, 0, 0, 10207, + 10208, 7, 15, 0, 0, 10208, 10209, 7, 5, 0, 0, 10209, 1676, 1, 0, 0, 0, + 10210, 10211, 7, 14, 0, 0, 10211, 10212, 7, 7, 0, 0, 10212, 10213, 7, 15, + 0, 0, 10213, 10214, 7, 5, 0, 0, 10214, 10215, 7, 15, 0, 0, 10215, 10216, + 7, 12, 0, 0, 10216, 10217, 7, 22, 0, 0, 10217, 1678, 1, 0, 0, 0, 10218, + 10219, 7, 14, 0, 0, 10219, 10220, 7, 7, 0, 0, 10220, 10221, 7, 12, 0, 0, + 10221, 10222, 7, 6, 0, 0, 10222, 10223, 7, 8, 0, 0, 10223, 10224, 7, 19, + 0, 0, 10224, 10225, 7, 15, 0, 0, 10225, 10226, 7, 4, 0, 0, 10226, 1680, + 1, 0, 0, 0, 10227, 10228, 7, 14, 0, 0, 10228, 10229, 7, 20, 0, 0, 10229, + 10230, 7, 3, 0, 0, 10230, 10231, 7, 8, 0, 0, 10231, 10232, 7, 3, 0, 0, + 10232, 10233, 7, 14, 0, 0, 10233, 10234, 7, 6, 0, 0, 10234, 10235, 7, 7, + 0, 0, 10235, 10236, 7, 8, 0, 0, 10236, 10237, 5, 95, 0, 0, 10237, 10238, + 7, 5, 0, 0, 10238, 10239, 7, 7, 0, 0, 10239, 10240, 7, 12, 0, 0, 10240, + 10241, 7, 22, 0, 0, 10241, 10242, 7, 6, 0, 0, 10242, 10243, 7, 20, 0, 0, + 10243, 1682, 1, 0, 0, 0, 10244, 10245, 7, 14, 0, 0, 10245, 10246, 7, 20, + 0, 0, 10246, 10247, 7, 3, 0, 0, 10247, 10248, 7, 8, 0, 0, 10248, 10249, + 7, 11, 0, 0, 10249, 10250, 7, 7, 0, 0, 10250, 10251, 7, 6, 0, 0, 10251, + 1684, 1, 0, 0, 0, 10252, 10253, 7, 14, 0, 0, 10253, 10254, 7, 20, 0, 0, + 10254, 10255, 7, 3, 0, 0, 10255, 10256, 7, 8, 0, 0, 10256, 10257, 5, 95, + 0, 0, 10257, 10258, 7, 5, 0, 0, 10258, 10259, 7, 7, 0, 0, 10259, 10260, + 7, 12, 0, 0, 10260, 10261, 7, 22, 0, 0, 10261, 10262, 7, 6, 0, 0, 10262, + 10263, 7, 20, 0, 0, 10263, 1686, 1, 0, 0, 0, 10264, 10265, 7, 14, 0, 0, + 10265, 10266, 7, 19, 0, 0, 10266, 10267, 7, 7, 0, 0, 10267, 10268, 7, 8, + 0, 0, 10268, 10269, 7, 14, 0, 0, 10269, 10270, 7, 15, 0, 0, 10270, 10271, + 7, 16, 0, 0, 10271, 10272, 7, 15, 0, 0, 10272, 10273, 7, 5, 0, 0, 10273, + 10274, 7, 15, 0, 0, 10274, 10275, 7, 6, 0, 0, 10275, 10276, 7, 10, 0, 0, + 10276, 1688, 1, 0, 0, 0, 10277, 10278, 7, 14, 0, 0, 10278, 10279, 7, 19, + 0, 0, 10279, 10280, 7, 5, 0, 0, 10280, 10281, 7, 5, 0, 0, 10281, 10282, + 7, 3, 0, 0, 10282, 10283, 7, 6, 0, 0, 10283, 10284, 7, 15, 0, 0, 10284, + 10285, 7, 19, 0, 0, 10285, 10286, 7, 12, 0, 0, 10286, 1690, 1, 0, 0, 0, + 10287, 10288, 7, 14, 0, 0, 10288, 10289, 7, 19, 0, 0, 10289, 10290, 7, + 23, 0, 0, 10290, 10291, 7, 25, 0, 0, 10291, 10292, 7, 8, 0, 0, 10292, 10293, + 7, 7, 0, 0, 10293, 10294, 7, 11, 0, 0, 10294, 10295, 7, 11, 0, 0, 10295, + 1692, 1, 0, 0, 0, 10296, 10297, 7, 14, 0, 0, 10297, 10298, 7, 19, 0, 0, + 10298, 10299, 7, 12, 0, 0, 10299, 10300, 7, 14, 0, 0, 10300, 10301, 7, + 3, 0, 0, 10301, 10302, 7, 6, 0, 0, 10302, 1694, 1, 0, 0, 0, 10303, 10304, + 7, 14, 0, 0, 10304, 10305, 7, 19, 0, 0, 10305, 10306, 7, 12, 0, 0, 10306, + 10307, 7, 14, 0, 0, 10307, 10308, 7, 3, 0, 0, 10308, 10309, 7, 6, 0, 0, + 10309, 10310, 5, 95, 0, 0, 10310, 10311, 7, 9, 0, 0, 10311, 10312, 7, 11, + 0, 0, 10312, 1696, 1, 0, 0, 0, 10313, 10314, 7, 14, 0, 0, 10314, 10315, + 7, 19, 0, 0, 10315, 10316, 7, 12, 0, 0, 10316, 10317, 7, 12, 0, 0, 10317, + 10318, 7, 7, 0, 0, 10318, 10319, 7, 14, 0, 0, 10319, 10320, 7, 6, 0, 0, + 10320, 10321, 7, 15, 0, 0, 10321, 10322, 7, 19, 0, 0, 10322, 10323, 7, + 12, 0, 0, 10323, 10324, 5, 95, 0, 0, 10324, 10325, 7, 15, 0, 0, 10325, + 10326, 7, 4, 0, 0, 10326, 1698, 1, 0, 0, 0, 10327, 10328, 7, 14, 0, 0, + 10328, 10329, 7, 19, 0, 0, 10329, 10330, 7, 12, 0, 0, 10330, 10331, 7, + 24, 0, 0, 10331, 1700, 1, 0, 0, 0, 10332, 10333, 7, 14, 0, 0, 10333, 10334, + 7, 19, 0, 0, 10334, 10335, 7, 12, 0, 0, 10335, 10336, 7, 24, 0, 0, 10336, + 10337, 7, 7, 0, 0, 10337, 10338, 7, 8, 0, 0, 10338, 10339, 7, 6, 0, 0, + 10339, 10340, 5, 95, 0, 0, 10340, 10341, 7, 6, 0, 0, 10341, 10342, 7, 13, + 0, 0, 10342, 1702, 1, 0, 0, 0, 10343, 10344, 7, 14, 0, 0, 10344, 10345, + 7, 19, 0, 0, 10345, 10346, 7, 11, 0, 0, 10346, 1704, 1, 0, 0, 0, 10347, + 10348, 7, 14, 0, 0, 10348, 10349, 7, 19, 0, 0, 10349, 10350, 7, 6, 0, 0, + 10350, 1706, 1, 0, 0, 0, 10351, 10352, 7, 14, 0, 0, 10352, 10353, 7, 8, + 0, 0, 10353, 10354, 7, 14, 0, 0, 10354, 10355, 5, 51, 0, 0, 10355, 10356, + 5, 50, 0, 0, 10356, 1708, 1, 0, 0, 0, 10357, 10358, 7, 14, 0, 0, 10358, + 10359, 7, 8, 0, 0, 10359, 10360, 7, 7, 0, 0, 10360, 10361, 7, 3, 0, 0, + 10361, 10362, 7, 6, 0, 0, 10362, 10363, 7, 7, 0, 0, 10363, 10364, 5, 95, + 0, 0, 10364, 10365, 7, 3, 0, 0, 10365, 10366, 7, 11, 0, 0, 10366, 10367, + 7, 10, 0, 0, 10367, 10368, 7, 23, 0, 0, 10368, 10369, 7, 23, 0, 0, 10369, + 10370, 7, 7, 0, 0, 10370, 10371, 7, 6, 0, 0, 10371, 10372, 7, 8, 0, 0, + 10372, 10373, 7, 15, 0, 0, 10373, 10374, 7, 14, 0, 0, 10374, 10375, 5, + 95, 0, 0, 10375, 10376, 7, 25, 0, 0, 10376, 10377, 7, 8, 0, 0, 10377, 10378, + 7, 15, 0, 0, 10378, 10379, 7, 24, 0, 0, 10379, 10380, 5, 95, 0, 0, 10380, + 10381, 7, 21, 0, 0, 10381, 10382, 7, 7, 0, 0, 10382, 10383, 7, 10, 0, 0, + 10383, 1710, 1, 0, 0, 0, 10384, 10385, 7, 14, 0, 0, 10385, 10386, 7, 8, + 0, 0, 10386, 10387, 7, 7, 0, 0, 10387, 10388, 7, 3, 0, 0, 10388, 10389, + 7, 6, 0, 0, 10389, 10390, 7, 7, 0, 0, 10390, 10391, 5, 95, 0, 0, 10391, + 10392, 7, 3, 0, 0, 10392, 10393, 7, 11, 0, 0, 10393, 10394, 7, 10, 0, 0, + 10394, 10395, 7, 23, 0, 0, 10395, 10396, 7, 23, 0, 0, 10396, 10397, 7, + 7, 0, 0, 10397, 10398, 7, 6, 0, 0, 10398, 10399, 7, 8, 0, 0, 10399, 10400, + 7, 15, 0, 0, 10400, 10401, 7, 14, 0, 0, 10401, 10402, 5, 95, 0, 0, 10402, + 10403, 7, 25, 0, 0, 10403, 10404, 7, 17, 0, 0, 10404, 10405, 7, 16, 0, + 0, 10405, 10406, 5, 95, 0, 0, 10406, 10407, 7, 21, 0, 0, 10407, 10408, + 7, 7, 0, 0, 10408, 10409, 7, 10, 0, 0, 10409, 1712, 1, 0, 0, 0, 10410, + 10411, 7, 14, 0, 0, 10411, 10412, 7, 8, 0, 0, 10412, 10413, 7, 7, 0, 0, + 10413, 10414, 7, 3, 0, 0, 10414, 10415, 7, 6, 0, 0, 10415, 10416, 7, 7, + 0, 0, 10416, 10417, 5, 95, 0, 0, 10417, 10418, 7, 4, 0, 0, 10418, 10419, + 7, 20, 0, 0, 10419, 10420, 5, 95, 0, 0, 10420, 10421, 7, 25, 0, 0, 10421, + 10422, 7, 3, 0, 0, 10422, 10423, 7, 8, 0, 0, 10423, 10424, 7, 3, 0, 0, + 10424, 10425, 7, 23, 0, 0, 10425, 10426, 7, 7, 0, 0, 10426, 10427, 7, 6, + 0, 0, 10427, 10428, 7, 7, 0, 0, 10428, 10429, 7, 8, 0, 0, 10429, 10430, + 7, 11, 0, 0, 10430, 1714, 1, 0, 0, 0, 10431, 10432, 7, 14, 0, 0, 10432, + 10433, 7, 8, 0, 0, 10433, 10434, 7, 7, 0, 0, 10434, 10435, 7, 3, 0, 0, + 10435, 10436, 7, 6, 0, 0, 10436, 10437, 7, 7, 0, 0, 10437, 10438, 5, 95, + 0, 0, 10438, 10439, 7, 4, 0, 0, 10439, 10440, 7, 15, 0, 0, 10440, 10441, + 7, 22, 0, 0, 10441, 10442, 7, 7, 0, 0, 10442, 10443, 7, 11, 0, 0, 10443, + 10444, 7, 6, 0, 0, 10444, 1716, 1, 0, 0, 0, 10445, 10446, 7, 14, 0, 0, + 10446, 10447, 7, 8, 0, 0, 10447, 10448, 7, 19, 0, 0, 10448, 10449, 7, 11, + 0, 0, 10449, 10450, 7, 11, 0, 0, 10450, 10451, 7, 7, 0, 0, 10451, 10452, + 7, 11, 0, 0, 10452, 1718, 1, 0, 0, 0, 10453, 10454, 7, 4, 0, 0, 10454, + 10455, 7, 3, 0, 0, 10455, 10456, 7, 6, 0, 0, 10456, 10457, 7, 7, 0, 0, + 10457, 10458, 7, 4, 0, 0, 10458, 10459, 7, 15, 0, 0, 10459, 10460, 7, 18, + 0, 0, 10460, 10461, 7, 18, 0, 0, 10461, 1720, 1, 0, 0, 0, 10462, 10463, + 7, 4, 0, 0, 10463, 10464, 7, 3, 0, 0, 10464, 10465, 7, 6, 0, 0, 10465, + 10466, 7, 7, 0, 0, 10466, 10467, 5, 95, 0, 0, 10467, 10468, 7, 18, 0, 0, + 10468, 10469, 7, 19, 0, 0, 10469, 10470, 7, 8, 0, 0, 10470, 10471, 7, 23, + 0, 0, 10471, 10472, 7, 3, 0, 0, 10472, 10473, 7, 6, 0, 0, 10473, 1722, + 1, 0, 0, 0, 10474, 10475, 7, 4, 0, 0, 10475, 10476, 7, 3, 0, 0, 10476, + 10477, 7, 10, 0, 0, 10477, 10478, 7, 12, 0, 0, 10478, 10479, 7, 3, 0, 0, + 10479, 10480, 7, 23, 0, 0, 10480, 10481, 7, 7, 0, 0, 10481, 1724, 1, 0, + 0, 0, 10482, 10483, 7, 4, 0, 0, 10483, 10484, 7, 3, 0, 0, 10484, 10485, + 7, 10, 0, 0, 10485, 10486, 7, 19, 0, 0, 10486, 10487, 7, 18, 0, 0, 10487, + 10488, 7, 23, 0, 0, 10488, 10489, 7, 19, 0, 0, 10489, 10490, 7, 12, 0, + 0, 10490, 10491, 7, 6, 0, 0, 10491, 10492, 7, 20, 0, 0, 10492, 1726, 1, + 0, 0, 0, 10493, 10494, 7, 4, 0, 0, 10494, 10495, 7, 3, 0, 0, 10495, 10496, + 7, 10, 0, 0, 10496, 10497, 7, 19, 0, 0, 10497, 10498, 7, 18, 0, 0, 10498, + 10499, 7, 9, 0, 0, 10499, 10500, 7, 7, 0, 0, 10500, 10501, 7, 7, 0, 0, + 10501, 10502, 7, 21, 0, 0, 10502, 1728, 1, 0, 0, 0, 10503, 10504, 7, 4, + 0, 0, 10504, 10505, 7, 3, 0, 0, 10505, 10506, 7, 10, 0, 0, 10506, 10507, + 7, 19, 0, 0, 10507, 10508, 7, 18, 0, 0, 10508, 10509, 7, 10, 0, 0, 10509, + 10510, 7, 7, 0, 0, 10510, 10511, 7, 3, 0, 0, 10511, 10512, 7, 8, 0, 0, + 10512, 1730, 1, 0, 0, 0, 10513, 10514, 7, 4, 0, 0, 10514, 10515, 7, 7, + 0, 0, 10515, 10516, 7, 14, 0, 0, 10516, 10517, 7, 19, 0, 0, 10517, 10518, + 7, 4, 0, 0, 10518, 10519, 7, 7, 0, 0, 10519, 1732, 1, 0, 0, 0, 10520, 10521, + 7, 4, 0, 0, 10521, 10522, 7, 7, 0, 0, 10522, 10523, 7, 22, 0, 0, 10523, + 10524, 7, 8, 0, 0, 10524, 10525, 7, 7, 0, 0, 10525, 10526, 7, 7, 0, 0, + 10526, 10527, 7, 11, 0, 0, 10527, 1734, 1, 0, 0, 0, 10528, 10529, 7, 4, + 0, 0, 10529, 10530, 7, 7, 0, 0, 10530, 10531, 7, 11, 0, 0, 10531, 10532, + 5, 95, 0, 0, 10532, 10533, 7, 4, 0, 0, 10533, 10534, 7, 7, 0, 0, 10534, + 10535, 7, 14, 0, 0, 10535, 10536, 7, 8, 0, 0, 10536, 10537, 7, 10, 0, 0, + 10537, 10538, 7, 25, 0, 0, 10538, 10539, 7, 6, 0, 0, 10539, 1736, 1, 0, + 0, 0, 10540, 10541, 7, 4, 0, 0, 10541, 10542, 7, 7, 0, 0, 10542, 10543, + 7, 11, 0, 0, 10543, 10544, 5, 95, 0, 0, 10544, 10545, 7, 7, 0, 0, 10545, + 10546, 7, 12, 0, 0, 10546, 10547, 7, 14, 0, 0, 10547, 10548, 7, 8, 0, 0, + 10548, 10549, 7, 10, 0, 0, 10549, 10550, 7, 25, 0, 0, 10550, 10551, 7, + 6, 0, 0, 10551, 1738, 1, 0, 0, 0, 10552, 10553, 7, 4, 0, 0, 10553, 10554, + 7, 15, 0, 0, 10554, 10555, 7, 23, 0, 0, 10555, 10556, 7, 7, 0, 0, 10556, + 10557, 7, 12, 0, 0, 10557, 10558, 7, 11, 0, 0, 10558, 10559, 7, 15, 0, + 0, 10559, 10560, 7, 19, 0, 0, 10560, 10561, 7, 12, 0, 0, 10561, 1740, 1, + 0, 0, 0, 10562, 10563, 7, 4, 0, 0, 10563, 10564, 7, 15, 0, 0, 10564, 10565, + 7, 11, 0, 0, 10565, 10566, 7, 27, 0, 0, 10566, 10567, 7, 19, 0, 0, 10567, + 10568, 7, 15, 0, 0, 10568, 10569, 7, 12, 0, 0, 10569, 10570, 7, 6, 0, 0, + 10570, 1742, 1, 0, 0, 0, 10571, 10572, 7, 4, 0, 0, 10572, 10573, 7, 15, + 0, 0, 10573, 10574, 7, 11, 0, 0, 10574, 10575, 7, 6, 0, 0, 10575, 10576, + 7, 3, 0, 0, 10576, 10577, 7, 12, 0, 0, 10577, 10578, 7, 14, 0, 0, 10578, + 10579, 7, 7, 0, 0, 10579, 1744, 1, 0, 0, 0, 10580, 10581, 7, 7, 0, 0, 10581, + 10582, 7, 5, 0, 0, 10582, 10583, 7, 6, 0, 0, 10583, 1746, 1, 0, 0, 0, 10584, + 10585, 7, 7, 0, 0, 10585, 10586, 7, 12, 0, 0, 10586, 10587, 7, 14, 0, 0, + 10587, 10588, 7, 19, 0, 0, 10588, 10589, 7, 4, 0, 0, 10589, 10590, 7, 7, + 0, 0, 10590, 1748, 1, 0, 0, 0, 10591, 10592, 7, 7, 0, 0, 10592, 10593, + 7, 12, 0, 0, 10593, 10594, 7, 14, 0, 0, 10594, 10595, 7, 8, 0, 0, 10595, + 10596, 7, 10, 0, 0, 10596, 10597, 7, 25, 0, 0, 10597, 10598, 7, 6, 0, 0, + 10598, 1750, 1, 0, 0, 0, 10599, 10600, 7, 7, 0, 0, 10600, 10601, 7, 12, + 0, 0, 10601, 10602, 7, 4, 0, 0, 10602, 10603, 7, 25, 0, 0, 10603, 10604, + 7, 19, 0, 0, 10604, 10605, 7, 15, 0, 0, 10605, 10606, 7, 12, 0, 0, 10606, + 10607, 7, 6, 0, 0, 10607, 1752, 1, 0, 0, 0, 10608, 10609, 7, 7, 0, 0, 10609, + 10610, 7, 12, 0, 0, 10610, 10611, 7, 22, 0, 0, 10611, 10612, 7, 15, 0, + 0, 10612, 10613, 7, 12, 0, 0, 10613, 10614, 7, 7, 0, 0, 10614, 10615, 5, + 95, 0, 0, 10615, 10616, 7, 3, 0, 0, 10616, 10617, 7, 6, 0, 0, 10617, 10618, + 7, 6, 0, 0, 10618, 10619, 7, 8, 0, 0, 10619, 10620, 7, 15, 0, 0, 10620, + 10621, 7, 16, 0, 0, 10621, 10622, 7, 17, 0, 0, 10622, 10623, 7, 6, 0, 0, + 10623, 10624, 7, 7, 0, 0, 10624, 1754, 1, 0, 0, 0, 10625, 10626, 7, 7, + 0, 0, 10626, 10627, 7, 12, 0, 0, 10627, 10628, 7, 24, 0, 0, 10628, 10629, + 7, 7, 0, 0, 10629, 10630, 7, 5, 0, 0, 10630, 10631, 7, 19, 0, 0, 10631, + 10632, 7, 25, 0, 0, 10632, 10633, 7, 7, 0, 0, 10633, 1756, 1, 0, 0, 0, + 10634, 10635, 7, 7, 0, 0, 10635, 10636, 7, 28, 0, 0, 10636, 10637, 7, 17, + 0, 0, 10637, 10638, 7, 3, 0, 0, 10638, 10639, 7, 5, 0, 0, 10639, 10640, + 7, 11, 0, 0, 10640, 1758, 1, 0, 0, 0, 10641, 10642, 7, 7, 0, 0, 10642, + 10643, 7, 26, 0, 0, 10643, 10644, 7, 25, 0, 0, 10644, 1760, 1, 0, 0, 0, + 10645, 10646, 7, 7, 0, 0, 10646, 10647, 7, 26, 0, 0, 10647, 10648, 7, 25, + 0, 0, 10648, 10649, 7, 19, 0, 0, 10649, 10650, 7, 8, 0, 0, 10650, 10651, + 7, 6, 0, 0, 10651, 10652, 5, 95, 0, 0, 10652, 10653, 7, 11, 0, 0, 10653, + 10654, 7, 7, 0, 0, 10654, 10655, 7, 6, 0, 0, 10655, 1762, 1, 0, 0, 0, 10656, + 10657, 7, 7, 0, 0, 10657, 10658, 7, 26, 0, 0, 10658, 10659, 7, 6, 0, 0, + 10659, 10660, 7, 7, 0, 0, 10660, 10661, 7, 8, 0, 0, 10661, 10662, 7, 15, + 0, 0, 10662, 10663, 7, 19, 0, 0, 10663, 10664, 7, 8, 0, 0, 10664, 10665, + 7, 8, 0, 0, 10665, 10666, 7, 15, 0, 0, 10666, 10667, 7, 12, 0, 0, 10667, + 10668, 7, 22, 0, 0, 10668, 1764, 1, 0, 0, 0, 10669, 10670, 7, 7, 0, 0, + 10670, 10671, 7, 26, 0, 0, 10671, 10672, 7, 6, 0, 0, 10672, 10673, 7, 8, + 0, 0, 10673, 10674, 7, 3, 0, 0, 10674, 10675, 7, 14, 0, 0, 10675, 10676, + 7, 6, 0, 0, 10676, 10677, 7, 24, 0, 0, 10677, 10678, 7, 3, 0, 0, 10678, + 10679, 7, 5, 0, 0, 10679, 10680, 7, 17, 0, 0, 10680, 10681, 7, 7, 0, 0, + 10681, 1766, 1, 0, 0, 0, 10682, 10683, 7, 18, 0, 0, 10683, 10684, 7, 15, + 0, 0, 10684, 10685, 7, 7, 0, 0, 10685, 10686, 7, 5, 0, 0, 10686, 10687, + 7, 4, 0, 0, 10687, 1768, 1, 0, 0, 0, 10688, 10689, 7, 18, 0, 0, 10689, + 10690, 7, 15, 0, 0, 10690, 10691, 7, 12, 0, 0, 10691, 10692, 7, 4, 0, 0, + 10692, 10693, 5, 95, 0, 0, 10693, 10694, 7, 15, 0, 0, 10694, 10695, 7, + 12, 0, 0, 10695, 10696, 5, 95, 0, 0, 10696, 10697, 7, 11, 0, 0, 10697, + 10698, 7, 7, 0, 0, 10698, 10699, 7, 6, 0, 0, 10699, 1770, 1, 0, 0, 0, 10700, + 10701, 7, 18, 0, 0, 10701, 10702, 7, 5, 0, 0, 10702, 10703, 7, 19, 0, 0, + 10703, 10704, 7, 19, 0, 0, 10704, 10705, 7, 8, 0, 0, 10705, 1772, 1, 0, + 0, 0, 10706, 10707, 7, 18, 0, 0, 10707, 10708, 7, 19, 0, 0, 10708, 10709, + 7, 8, 0, 0, 10709, 10710, 7, 23, 0, 0, 10710, 10711, 7, 3, 0, 0, 10711, + 10712, 7, 6, 0, 0, 10712, 1774, 1, 0, 0, 0, 10713, 10714, 7, 18, 0, 0, + 10714, 10715, 7, 19, 0, 0, 10715, 10716, 7, 17, 0, 0, 10716, 10717, 7, + 12, 0, 0, 10717, 10718, 7, 4, 0, 0, 10718, 10719, 5, 95, 0, 0, 10719, 10720, + 7, 8, 0, 0, 10720, 10721, 7, 19, 0, 0, 10721, 10722, 7, 9, 0, 0, 10722, + 10723, 7, 11, 0, 0, 10723, 1776, 1, 0, 0, 0, 10724, 10725, 7, 18, 0, 0, + 10725, 10726, 7, 8, 0, 0, 10726, 10727, 7, 19, 0, 0, 10727, 10728, 7, 23, + 0, 0, 10728, 10729, 5, 95, 0, 0, 10729, 10730, 7, 16, 0, 0, 10730, 10731, + 7, 3, 0, 0, 10731, 10732, 7, 11, 0, 0, 10732, 10733, 7, 7, 0, 0, 10733, + 10734, 5, 54, 0, 0, 10734, 10735, 5, 52, 0, 0, 10735, 1778, 1, 0, 0, 0, + 10736, 10737, 7, 18, 0, 0, 10737, 10738, 7, 8, 0, 0, 10738, 10739, 7, 19, + 0, 0, 10739, 10740, 7, 23, 0, 0, 10740, 10741, 5, 95, 0, 0, 10741, 10742, + 7, 4, 0, 0, 10742, 10743, 7, 3, 0, 0, 10743, 10744, 7, 10, 0, 0, 10744, + 10745, 7, 11, 0, 0, 10745, 1780, 1, 0, 0, 0, 10746, 10747, 7, 18, 0, 0, + 10747, 10748, 7, 8, 0, 0, 10748, 10749, 7, 19, 0, 0, 10749, 10750, 7, 23, + 0, 0, 10750, 10751, 5, 95, 0, 0, 10751, 10752, 7, 17, 0, 0, 10752, 10753, + 7, 12, 0, 0, 10753, 10754, 7, 15, 0, 0, 10754, 10755, 7, 26, 0, 0, 10755, + 10756, 7, 6, 0, 0, 10756, 10757, 7, 15, 0, 0, 10757, 10758, 7, 23, 0, 0, + 10758, 10759, 7, 7, 0, 0, 10759, 1782, 1, 0, 0, 0, 10760, 10761, 7, 22, + 0, 0, 10761, 10762, 7, 7, 0, 0, 10762, 10763, 7, 19, 0, 0, 10763, 10764, + 7, 23, 0, 0, 10764, 10765, 7, 14, 0, 0, 10765, 10766, 7, 19, 0, 0, 10766, + 10767, 7, 5, 0, 0, 10767, 10768, 7, 5, 0, 0, 10768, 10769, 7, 18, 0, 0, + 10769, 10770, 7, 8, 0, 0, 10770, 10771, 7, 19, 0, 0, 10771, 10772, 7, 23, + 0, 0, 10772, 10773, 7, 6, 0, 0, 10773, 10774, 7, 7, 0, 0, 10774, 10775, + 7, 26, 0, 0, 10775, 10776, 7, 6, 0, 0, 10776, 1784, 1, 0, 0, 0, 10777, + 10778, 7, 22, 0, 0, 10778, 10779, 7, 7, 0, 0, 10779, 10780, 7, 19, 0, 0, + 10780, 10781, 7, 23, 0, 0, 10781, 10782, 7, 14, 0, 0, 10782, 10783, 7, + 19, 0, 0, 10783, 10784, 7, 5, 0, 0, 10784, 10785, 7, 5, 0, 0, 10785, 10786, + 7, 18, 0, 0, 10786, 10787, 7, 8, 0, 0, 10787, 10788, 7, 19, 0, 0, 10788, + 10789, 7, 23, 0, 0, 10789, 10790, 7, 9, 0, 0, 10790, 10791, 7, 21, 0, 0, + 10791, 10792, 7, 16, 0, 0, 10792, 1786, 1, 0, 0, 0, 10793, 10794, 7, 22, + 0, 0, 10794, 10795, 7, 7, 0, 0, 10795, 10796, 7, 19, 0, 0, 10796, 10797, + 7, 23, 0, 0, 10797, 10798, 7, 7, 0, 0, 10798, 10799, 7, 6, 0, 0, 10799, + 10800, 7, 8, 0, 0, 10800, 10801, 7, 10, 0, 0, 10801, 10802, 7, 14, 0, 0, + 10802, 10803, 7, 19, 0, 0, 10803, 10804, 7, 5, 0, 0, 10804, 10805, 7, 5, + 0, 0, 10805, 10806, 7, 7, 0, 0, 10806, 10807, 7, 14, 0, 0, 10807, 10808, + 7, 6, 0, 0, 10808, 10809, 7, 15, 0, 0, 10809, 10810, 7, 19, 0, 0, 10810, + 10811, 7, 12, 0, 0, 10811, 10812, 7, 18, 0, 0, 10812, 10813, 7, 8, 0, 0, + 10813, 10814, 7, 19, 0, 0, 10814, 10815, 7, 23, 0, 0, 10815, 10816, 7, + 6, 0, 0, 10816, 10817, 7, 7, 0, 0, 10817, 10818, 7, 26, 0, 0, 10818, 10819, + 7, 6, 0, 0, 10819, 1788, 1, 0, 0, 0, 10820, 10821, 7, 22, 0, 0, 10821, + 10822, 7, 7, 0, 0, 10822, 10823, 7, 19, 0, 0, 10823, 10824, 7, 23, 0, 0, + 10824, 10825, 7, 7, 0, 0, 10825, 10826, 7, 6, 0, 0, 10826, 10827, 7, 8, + 0, 0, 10827, 10828, 7, 10, 0, 0, 10828, 10829, 7, 14, 0, 0, 10829, 10830, + 7, 19, 0, 0, 10830, 10831, 7, 5, 0, 0, 10831, 10832, 7, 5, 0, 0, 10832, + 10833, 7, 7, 0, 0, 10833, 10834, 7, 14, 0, 0, 10834, 10835, 7, 6, 0, 0, + 10835, 10836, 7, 15, 0, 0, 10836, 10837, 7, 19, 0, 0, 10837, 10838, 7, + 12, 0, 0, 10838, 10839, 7, 18, 0, 0, 10839, 10840, 7, 8, 0, 0, 10840, 10841, + 7, 19, 0, 0, 10841, 10842, 7, 23, 0, 0, 10842, 10843, 7, 9, 0, 0, 10843, + 10844, 7, 21, 0, 0, 10844, 10845, 7, 16, 0, 0, 10845, 1790, 1, 0, 0, 0, + 10846, 10847, 7, 22, 0, 0, 10847, 10848, 7, 7, 0, 0, 10848, 10849, 7, 19, + 0, 0, 10849, 10850, 7, 23, 0, 0, 10850, 10851, 7, 7, 0, 0, 10851, 10852, + 7, 6, 0, 0, 10852, 10853, 7, 8, 0, 0, 10853, 10854, 7, 10, 0, 0, 10854, + 10855, 7, 18, 0, 0, 10855, 10856, 7, 8, 0, 0, 10856, 10857, 7, 19, 0, 0, + 10857, 10858, 7, 23, 0, 0, 10858, 10859, 7, 6, 0, 0, 10859, 10860, 7, 7, + 0, 0, 10860, 10861, 7, 26, 0, 0, 10861, 10862, 7, 6, 0, 0, 10862, 1792, + 1, 0, 0, 0, 10863, 10864, 7, 22, 0, 0, 10864, 10865, 7, 7, 0, 0, 10865, + 10866, 7, 19, 0, 0, 10866, 10867, 7, 23, 0, 0, 10867, 10868, 7, 7, 0, 0, + 10868, 10869, 7, 6, 0, 0, 10869, 10870, 7, 8, 0, 0, 10870, 10871, 7, 10, + 0, 0, 10871, 10872, 7, 18, 0, 0, 10872, 10873, 7, 8, 0, 0, 10873, 10874, + 7, 19, 0, 0, 10874, 10875, 7, 23, 0, 0, 10875, 10876, 7, 9, 0, 0, 10876, + 10877, 7, 21, 0, 0, 10877, 10878, 7, 16, 0, 0, 10878, 1794, 1, 0, 0, 0, + 10879, 10880, 7, 22, 0, 0, 10880, 10881, 7, 7, 0, 0, 10881, 10882, 7, 19, + 0, 0, 10882, 10883, 7, 23, 0, 0, 10883, 10884, 7, 7, 0, 0, 10884, 10885, + 7, 6, 0, 0, 10885, 10886, 7, 8, 0, 0, 10886, 10887, 7, 10, 0, 0, 10887, + 10888, 7, 12, 0, 0, 10888, 1796, 1, 0, 0, 0, 10889, 10890, 7, 22, 0, 0, + 10890, 10891, 7, 7, 0, 0, 10891, 10892, 7, 19, 0, 0, 10892, 10893, 7, 23, + 0, 0, 10893, 10894, 7, 7, 0, 0, 10894, 10895, 7, 6, 0, 0, 10895, 10896, + 7, 8, 0, 0, 10896, 10897, 7, 10, 0, 0, 10897, 10898, 7, 6, 0, 0, 10898, + 10899, 7, 10, 0, 0, 10899, 10900, 7, 25, 0, 0, 10900, 10901, 7, 7, 0, 0, + 10901, 1798, 1, 0, 0, 0, 10902, 10903, 7, 22, 0, 0, 10903, 10904, 7, 7, + 0, 0, 10904, 10905, 7, 19, 0, 0, 10905, 10906, 7, 23, 0, 0, 10906, 10907, + 7, 18, 0, 0, 10907, 10908, 7, 8, 0, 0, 10908, 10909, 7, 19, 0, 0, 10909, + 10910, 7, 23, 0, 0, 10910, 10911, 7, 6, 0, 0, 10911, 10912, 7, 7, 0, 0, + 10912, 10913, 7, 26, 0, 0, 10913, 10914, 7, 6, 0, 0, 10914, 1800, 1, 0, + 0, 0, 10915, 10916, 7, 22, 0, 0, 10916, 10917, 7, 7, 0, 0, 10917, 10918, + 7, 19, 0, 0, 10918, 10919, 7, 23, 0, 0, 10919, 10920, 7, 18, 0, 0, 10920, + 10921, 7, 8, 0, 0, 10921, 10922, 7, 19, 0, 0, 10922, 10923, 7, 23, 0, 0, + 10923, 10924, 7, 9, 0, 0, 10924, 10925, 7, 21, 0, 0, 10925, 10926, 7, 16, + 0, 0, 10926, 1802, 1, 0, 0, 0, 10927, 10928, 7, 22, 0, 0, 10928, 10929, + 7, 7, 0, 0, 10929, 10930, 7, 6, 0, 0, 10930, 10931, 5, 95, 0, 0, 10931, + 10932, 7, 18, 0, 0, 10932, 10933, 7, 19, 0, 0, 10933, 10934, 7, 8, 0, 0, + 10934, 10935, 7, 23, 0, 0, 10935, 10936, 7, 3, 0, 0, 10936, 10937, 7, 6, + 0, 0, 10937, 1804, 1, 0, 0, 0, 10938, 10939, 7, 22, 0, 0, 10939, 10940, + 7, 7, 0, 0, 10940, 10941, 7, 6, 0, 0, 10941, 10942, 5, 95, 0, 0, 10942, + 10943, 7, 5, 0, 0, 10943, 10944, 7, 19, 0, 0, 10944, 10945, 7, 14, 0, 0, + 10945, 10946, 7, 21, 0, 0, 10946, 1806, 1, 0, 0, 0, 10947, 10948, 7, 22, + 0, 0, 10948, 10949, 7, 5, 0, 0, 10949, 10950, 7, 7, 0, 0, 10950, 10951, + 7, 12, 0, 0, 10951, 10952, 7, 22, 0, 0, 10952, 10953, 7, 6, 0, 0, 10953, + 10954, 7, 20, 0, 0, 10954, 1808, 1, 0, 0, 0, 10955, 10956, 7, 22, 0, 0, + 10956, 10957, 7, 8, 0, 0, 10957, 10958, 7, 7, 0, 0, 10958, 10959, 7, 3, + 0, 0, 10959, 10960, 7, 6, 0, 0, 10960, 10961, 7, 7, 0, 0, 10961, 10962, + 7, 11, 0, 0, 10962, 10963, 7, 6, 0, 0, 10963, 1810, 1, 0, 0, 0, 10964, + 10965, 7, 22, 0, 0, 10965, 10966, 7, 6, 0, 0, 10966, 10967, 7, 15, 0, 0, + 10967, 10968, 7, 4, 0, 0, 10968, 10969, 5, 95, 0, 0, 10969, 10970, 7, 11, + 0, 0, 10970, 10971, 7, 17, 0, 0, 10971, 10972, 7, 16, 0, 0, 10972, 10973, + 7, 11, 0, 0, 10973, 10974, 7, 7, 0, 0, 10974, 10975, 7, 6, 0, 0, 10975, + 1812, 1, 0, 0, 0, 10976, 10977, 7, 22, 0, 0, 10977, 10978, 7, 6, 0, 0, + 10978, 10979, 7, 15, 0, 0, 10979, 10980, 7, 4, 0, 0, 10980, 10981, 5, 95, + 0, 0, 10981, 10982, 7, 11, 0, 0, 10982, 10983, 7, 17, 0, 0, 10983, 10984, + 7, 16, 0, 0, 10984, 10985, 7, 6, 0, 0, 10985, 10986, 7, 8, 0, 0, 10986, + 10987, 7, 3, 0, 0, 10987, 10988, 7, 14, 0, 0, 10988, 10989, 7, 6, 0, 0, + 10989, 1814, 1, 0, 0, 0, 10990, 10991, 7, 20, 0, 0, 10991, 10992, 7, 7, + 0, 0, 10992, 10993, 7, 26, 0, 0, 10993, 1816, 1, 0, 0, 0, 10994, 10995, + 7, 15, 0, 0, 10995, 10996, 7, 18, 0, 0, 10996, 10997, 7, 12, 0, 0, 10997, + 10998, 7, 17, 0, 0, 10998, 10999, 7, 5, 0, 0, 10999, 11000, 7, 5, 0, 0, + 11000, 1818, 1, 0, 0, 0, 11001, 11002, 7, 15, 0, 0, 11002, 11003, 7, 12, + 0, 0, 11003, 11004, 7, 7, 0, 0, 11004, 11005, 7, 6, 0, 0, 11005, 11006, + 5, 54, 0, 0, 11006, 11007, 5, 95, 0, 0, 11007, 11008, 7, 3, 0, 0, 11008, + 11009, 7, 6, 0, 0, 11009, 11010, 7, 19, 0, 0, 11010, 11011, 7, 12, 0, 0, + 11011, 1820, 1, 0, 0, 0, 11012, 11013, 7, 15, 0, 0, 11013, 11014, 7, 12, + 0, 0, 11014, 11015, 7, 7, 0, 0, 11015, 11016, 7, 6, 0, 0, 11016, 11017, + 5, 54, 0, 0, 11017, 11018, 5, 95, 0, 0, 11018, 11019, 7, 12, 0, 0, 11019, + 11020, 7, 6, 0, 0, 11020, 11021, 7, 19, 0, 0, 11021, 11022, 7, 3, 0, 0, + 11022, 1822, 1, 0, 0, 0, 11023, 11024, 7, 15, 0, 0, 11024, 11025, 7, 12, + 0, 0, 11025, 11026, 7, 7, 0, 0, 11026, 11027, 7, 6, 0, 0, 11027, 11028, + 5, 95, 0, 0, 11028, 11029, 7, 3, 0, 0, 11029, 11030, 7, 6, 0, 0, 11030, + 11031, 7, 19, 0, 0, 11031, 11032, 7, 12, 0, 0, 11032, 1824, 1, 0, 0, 0, + 11033, 11034, 7, 15, 0, 0, 11034, 11035, 7, 12, 0, 0, 11035, 11036, 7, + 7, 0, 0, 11036, 11037, 7, 6, 0, 0, 11037, 11038, 5, 95, 0, 0, 11038, 11039, + 7, 12, 0, 0, 11039, 11040, 7, 6, 0, 0, 11040, 11041, 7, 19, 0, 0, 11041, + 11042, 7, 3, 0, 0, 11042, 1826, 1, 0, 0, 0, 11043, 11044, 7, 15, 0, 0, + 11044, 11045, 7, 12, 0, 0, 11045, 11046, 7, 11, 0, 0, 11046, 11047, 7, + 6, 0, 0, 11047, 11048, 7, 8, 0, 0, 11048, 1828, 1, 0, 0, 0, 11049, 11050, + 7, 15, 0, 0, 11050, 11051, 7, 12, 0, 0, 11051, 11052, 7, 6, 0, 0, 11052, + 11053, 7, 7, 0, 0, 11053, 11054, 7, 8, 0, 0, 11054, 11055, 7, 15, 0, 0, + 11055, 11056, 7, 19, 0, 0, 11056, 11057, 7, 8, 0, 0, 11057, 11058, 7, 8, + 0, 0, 11058, 11059, 7, 15, 0, 0, 11059, 11060, 7, 12, 0, 0, 11060, 11061, + 7, 22, 0, 0, 11061, 11062, 7, 12, 0, 0, 11062, 1830, 1, 0, 0, 0, 11063, + 11064, 7, 15, 0, 0, 11064, 11065, 7, 12, 0, 0, 11065, 11066, 7, 6, 0, 0, + 11066, 11067, 7, 7, 0, 0, 11067, 11068, 7, 8, 0, 0, 11068, 11069, 7, 11, + 0, 0, 11069, 11070, 7, 7, 0, 0, 11070, 11071, 7, 14, 0, 0, 11071, 11072, + 7, 6, 0, 0, 11072, 11073, 7, 11, 0, 0, 11073, 1832, 1, 0, 0, 0, 11074, + 11075, 7, 15, 0, 0, 11075, 11076, 7, 11, 0, 0, 11076, 11077, 7, 14, 0, + 0, 11077, 11078, 7, 5, 0, 0, 11078, 11079, 7, 19, 0, 0, 11079, 11080, 7, + 11, 0, 0, 11080, 11081, 7, 7, 0, 0, 11081, 11082, 7, 4, 0, 0, 11082, 1834, + 1, 0, 0, 0, 11083, 11084, 7, 15, 0, 0, 11084, 11085, 7, 11, 0, 0, 11085, + 11086, 7, 7, 0, 0, 11086, 11087, 7, 23, 0, 0, 11087, 11088, 7, 25, 0, 0, + 11088, 11089, 7, 6, 0, 0, 11089, 11090, 7, 10, 0, 0, 11090, 1836, 1, 0, + 0, 0, 11091, 11092, 7, 15, 0, 0, 11092, 11093, 7, 11, 0, 0, 11093, 11094, + 7, 12, 0, 0, 11094, 11095, 7, 17, 0, 0, 11095, 11096, 7, 5, 0, 0, 11096, + 11097, 7, 5, 0, 0, 11097, 1838, 1, 0, 0, 0, 11098, 11099, 7, 15, 0, 0, + 11099, 11100, 7, 11, 0, 0, 11100, 11101, 7, 11, 0, 0, 11101, 11102, 7, + 15, 0, 0, 11102, 11103, 7, 23, 0, 0, 11103, 11104, 7, 25, 0, 0, 11104, + 11105, 7, 5, 0, 0, 11105, 11106, 7, 7, 0, 0, 11106, 1840, 1, 0, 0, 0, 11107, + 11108, 7, 15, 0, 0, 11108, 11109, 7, 11, 0, 0, 11109, 11110, 5, 95, 0, + 0, 11110, 11111, 7, 18, 0, 0, 11111, 11112, 7, 8, 0, 0, 11112, 11113, 7, + 7, 0, 0, 11113, 11114, 7, 7, 0, 0, 11114, 11115, 5, 95, 0, 0, 11115, 11116, + 7, 5, 0, 0, 11116, 11117, 7, 19, 0, 0, 11117, 11118, 7, 14, 0, 0, 11118, + 11119, 7, 21, 0, 0, 11119, 1842, 1, 0, 0, 0, 11120, 11121, 7, 15, 0, 0, + 11121, 11122, 7, 11, 0, 0, 11122, 11123, 5, 95, 0, 0, 11123, 11124, 7, + 15, 0, 0, 11124, 11125, 7, 25, 0, 0, 11125, 11126, 7, 24, 0, 0, 11126, + 11127, 5, 52, 0, 0, 11127, 1844, 1, 0, 0, 0, 11128, 11129, 7, 15, 0, 0, + 11129, 11130, 7, 11, 0, 0, 11130, 11131, 5, 95, 0, 0, 11131, 11132, 7, + 15, 0, 0, 11132, 11133, 7, 25, 0, 0, 11133, 11134, 7, 24, 0, 0, 11134, + 11135, 5, 52, 0, 0, 11135, 11136, 5, 95, 0, 0, 11136, 11137, 7, 14, 0, + 0, 11137, 11138, 7, 19, 0, 0, 11138, 11139, 7, 23, 0, 0, 11139, 11140, + 7, 25, 0, 0, 11140, 11141, 7, 3, 0, 0, 11141, 11142, 7, 6, 0, 0, 11142, + 1846, 1, 0, 0, 0, 11143, 11144, 7, 15, 0, 0, 11144, 11145, 7, 11, 0, 0, + 11145, 11146, 5, 95, 0, 0, 11146, 11147, 7, 15, 0, 0, 11147, 11148, 7, + 25, 0, 0, 11148, 11149, 7, 24, 0, 0, 11149, 11150, 5, 52, 0, 0, 11150, + 11151, 5, 95, 0, 0, 11151, 11152, 7, 23, 0, 0, 11152, 11153, 7, 3, 0, 0, + 11153, 11154, 7, 25, 0, 0, 11154, 11155, 7, 25, 0, 0, 11155, 11156, 7, + 7, 0, 0, 11156, 11157, 7, 4, 0, 0, 11157, 1848, 1, 0, 0, 0, 11158, 11159, + 7, 15, 0, 0, 11159, 11160, 7, 11, 0, 0, 11160, 11161, 5, 95, 0, 0, 11161, + 11162, 7, 15, 0, 0, 11162, 11163, 7, 25, 0, 0, 11163, 11164, 7, 24, 0, + 0, 11164, 11165, 5, 54, 0, 0, 11165, 1850, 1, 0, 0, 0, 11166, 11167, 7, + 15, 0, 0, 11167, 11168, 7, 11, 0, 0, 11168, 11169, 5, 95, 0, 0, 11169, + 11170, 7, 17, 0, 0, 11170, 11171, 7, 11, 0, 0, 11171, 11172, 7, 7, 0, 0, + 11172, 11173, 7, 4, 0, 0, 11173, 11174, 5, 95, 0, 0, 11174, 11175, 7, 5, + 0, 0, 11175, 11176, 7, 19, 0, 0, 11176, 11177, 7, 14, 0, 0, 11177, 11178, + 7, 21, 0, 0, 11178, 1852, 1, 0, 0, 0, 11179, 11180, 7, 5, 0, 0, 11180, + 11181, 7, 3, 0, 0, 11181, 11182, 7, 11, 0, 0, 11182, 11183, 7, 6, 0, 0, + 11183, 11184, 5, 95, 0, 0, 11184, 11185, 7, 15, 0, 0, 11185, 11186, 7, + 12, 0, 0, 11186, 11187, 7, 11, 0, 0, 11187, 11188, 7, 7, 0, 0, 11188, 11189, + 7, 8, 0, 0, 11189, 11190, 7, 6, 0, 0, 11190, 11191, 5, 95, 0, 0, 11191, + 11192, 7, 15, 0, 0, 11192, 11193, 7, 4, 0, 0, 11193, 1854, 1, 0, 0, 0, + 11194, 11195, 7, 5, 0, 0, 11195, 11196, 7, 14, 0, 0, 11196, 11197, 7, 3, + 0, 0, 11197, 11198, 7, 11, 0, 0, 11198, 11199, 7, 7, 0, 0, 11199, 1856, + 1, 0, 0, 0, 11200, 11201, 7, 5, 0, 0, 11201, 11202, 7, 7, 0, 0, 11202, + 11203, 7, 3, 0, 0, 11203, 11204, 7, 11, 0, 0, 11204, 11205, 7, 6, 0, 0, + 11205, 1858, 1, 0, 0, 0, 11206, 11207, 7, 5, 0, 0, 11207, 11208, 7, 7, + 0, 0, 11208, 11209, 7, 12, 0, 0, 11209, 11210, 7, 22, 0, 0, 11210, 11211, + 7, 6, 0, 0, 11211, 11212, 7, 20, 0, 0, 11212, 1860, 1, 0, 0, 0, 11213, + 11214, 7, 5, 0, 0, 11214, 11215, 7, 15, 0, 0, 11215, 11216, 7, 12, 0, 0, + 11216, 11217, 7, 7, 0, 0, 11217, 11218, 7, 18, 0, 0, 11218, 11219, 7, 8, + 0, 0, 11219, 11220, 7, 19, 0, 0, 11220, 11221, 7, 23, 0, 0, 11221, 11222, + 7, 6, 0, 0, 11222, 11223, 7, 7, 0, 0, 11223, 11224, 7, 26, 0, 0, 11224, + 11225, 7, 6, 0, 0, 11225, 1862, 1, 0, 0, 0, 11226, 11227, 7, 5, 0, 0, 11227, + 11228, 7, 15, 0, 0, 11228, 11229, 7, 12, 0, 0, 11229, 11230, 7, 7, 0, 0, + 11230, 11231, 7, 18, 0, 0, 11231, 11232, 7, 8, 0, 0, 11232, 11233, 7, 19, + 0, 0, 11233, 11234, 7, 23, 0, 0, 11234, 11235, 7, 9, 0, 0, 11235, 11236, + 7, 21, 0, 0, 11236, 11237, 7, 16, 0, 0, 11237, 1864, 1, 0, 0, 0, 11238, + 11239, 7, 5, 0, 0, 11239, 11240, 7, 15, 0, 0, 11240, 11241, 7, 12, 0, 0, + 11241, 11242, 7, 7, 0, 0, 11242, 11243, 7, 11, 0, 0, 11243, 11244, 7, 6, + 0, 0, 11244, 11245, 7, 8, 0, 0, 11245, 11246, 7, 15, 0, 0, 11246, 11247, + 7, 12, 0, 0, 11247, 11248, 7, 22, 0, 0, 11248, 11249, 7, 18, 0, 0, 11249, + 11250, 7, 8, 0, 0, 11250, 11251, 7, 19, 0, 0, 11251, 11252, 7, 23, 0, 0, + 11252, 11253, 7, 6, 0, 0, 11253, 11254, 7, 7, 0, 0, 11254, 11255, 7, 26, + 0, 0, 11255, 11256, 7, 6, 0, 0, 11256, 1866, 1, 0, 0, 0, 11257, 11258, + 7, 5, 0, 0, 11258, 11259, 7, 15, 0, 0, 11259, 11260, 7, 12, 0, 0, 11260, + 11261, 7, 7, 0, 0, 11261, 11262, 7, 11, 0, 0, 11262, 11263, 7, 6, 0, 0, + 11263, 11264, 7, 8, 0, 0, 11264, 11265, 7, 15, 0, 0, 11265, 11266, 7, 12, + 0, 0, 11266, 11267, 7, 22, 0, 0, 11267, 11268, 7, 18, 0, 0, 11268, 11269, + 7, 8, 0, 0, 11269, 11270, 7, 19, 0, 0, 11270, 11271, 7, 23, 0, 0, 11271, + 11272, 7, 9, 0, 0, 11272, 11273, 7, 21, 0, 0, 11273, 11274, 7, 16, 0, 0, + 11274, 1868, 1, 0, 0, 0, 11275, 11276, 7, 5, 0, 0, 11276, 11277, 7, 12, + 0, 0, 11277, 1870, 1, 0, 0, 0, 11278, 11279, 7, 5, 0, 0, 11279, 11280, + 7, 19, 0, 0, 11280, 11281, 7, 3, 0, 0, 11281, 11282, 7, 4, 0, 0, 11282, + 11283, 5, 95, 0, 0, 11283, 11284, 7, 18, 0, 0, 11284, 11285, 7, 15, 0, + 0, 11285, 11286, 7, 5, 0, 0, 11286, 11287, 7, 7, 0, 0, 11287, 1872, 1, + 0, 0, 0, 11288, 11289, 7, 5, 0, 0, 11289, 11290, 7, 19, 0, 0, 11290, 11291, + 7, 14, 0, 0, 11291, 11292, 7, 3, 0, 0, 11292, 11293, 7, 6, 0, 0, 11293, + 11294, 7, 7, 0, 0, 11294, 1874, 1, 0, 0, 0, 11295, 11296, 7, 5, 0, 0, 11296, + 11297, 7, 19, 0, 0, 11297, 11298, 7, 22, 0, 0, 11298, 1876, 1, 0, 0, 0, + 11299, 11300, 7, 5, 0, 0, 11300, 11301, 7, 19, 0, 0, 11301, 11302, 7, 22, + 0, 0, 11302, 11303, 5, 49, 0, 0, 11303, 11304, 5, 48, 0, 0, 11304, 1878, + 1, 0, 0, 0, 11305, 11306, 7, 5, 0, 0, 11306, 11307, 7, 19, 0, 0, 11307, + 11308, 7, 22, 0, 0, 11308, 11309, 5, 50, 0, 0, 11309, 1880, 1, 0, 0, 0, + 11310, 11311, 7, 5, 0, 0, 11311, 11312, 7, 19, 0, 0, 11312, 11313, 7, 9, + 0, 0, 11313, 11314, 7, 7, 0, 0, 11314, 11315, 7, 8, 0, 0, 11315, 1882, + 1, 0, 0, 0, 11316, 11317, 7, 5, 0, 0, 11317, 11318, 7, 25, 0, 0, 11318, + 11319, 7, 3, 0, 0, 11319, 11320, 7, 4, 0, 0, 11320, 1884, 1, 0, 0, 0, 11321, + 11322, 7, 5, 0, 0, 11322, 11323, 7, 6, 0, 0, 11323, 11324, 7, 8, 0, 0, + 11324, 11325, 7, 15, 0, 0, 11325, 11326, 7, 23, 0, 0, 11326, 1886, 1, 0, + 0, 0, 11327, 11328, 7, 23, 0, 0, 11328, 11329, 7, 3, 0, 0, 11329, 11330, + 7, 21, 0, 0, 11330, 11331, 7, 7, 0, 0, 11331, 11332, 7, 4, 0, 0, 11332, + 11333, 7, 3, 0, 0, 11333, 11334, 7, 6, 0, 0, 11334, 11335, 7, 7, 0, 0, + 11335, 1888, 1, 0, 0, 0, 11336, 11337, 7, 23, 0, 0, 11337, 11338, 7, 3, + 0, 0, 11338, 11339, 7, 21, 0, 0, 11339, 11340, 7, 7, 0, 0, 11340, 11341, + 7, 6, 0, 0, 11341, 11342, 7, 15, 0, 0, 11342, 11343, 7, 23, 0, 0, 11343, + 11344, 7, 7, 0, 0, 11344, 1890, 1, 0, 0, 0, 11345, 11346, 7, 23, 0, 0, + 11346, 11347, 7, 3, 0, 0, 11347, 11348, 7, 21, 0, 0, 11348, 11349, 7, 7, + 0, 0, 11349, 11350, 5, 95, 0, 0, 11350, 11351, 7, 11, 0, 0, 11351, 11352, + 7, 7, 0, 0, 11352, 11353, 7, 6, 0, 0, 11353, 1892, 1, 0, 0, 0, 11354, 11355, + 7, 23, 0, 0, 11355, 11356, 7, 3, 0, 0, 11356, 11357, 7, 11, 0, 0, 11357, + 11358, 7, 6, 0, 0, 11358, 11359, 7, 7, 0, 0, 11359, 11360, 7, 8, 0, 0, + 11360, 11361, 5, 95, 0, 0, 11361, 11362, 7, 25, 0, 0, 11362, 11363, 7, + 19, 0, 0, 11363, 11364, 7, 11, 0, 0, 11364, 11365, 5, 95, 0, 0, 11365, + 11366, 7, 9, 0, 0, 11366, 11367, 7, 3, 0, 0, 11367, 11368, 7, 15, 0, 0, + 11368, 11369, 7, 6, 0, 0, 11369, 1894, 1, 0, 0, 0, 11370, 11371, 7, 23, + 0, 0, 11371, 11372, 7, 16, 0, 0, 11372, 11373, 7, 8, 0, 0, 11373, 11374, + 7, 14, 0, 0, 11374, 11375, 7, 19, 0, 0, 11375, 11376, 7, 12, 0, 0, 11376, + 11377, 7, 6, 0, 0, 11377, 11378, 7, 3, 0, 0, 11378, 11379, 7, 15, 0, 0, + 11379, 11380, 7, 12, 0, 0, 11380, 11381, 7, 11, 0, 0, 11381, 1896, 1, 0, + 0, 0, 11382, 11383, 7, 23, 0, 0, 11383, 11384, 7, 16, 0, 0, 11384, 11385, + 7, 8, 0, 0, 11385, 11386, 7, 4, 0, 0, 11386, 11387, 7, 15, 0, 0, 11387, + 11388, 7, 11, 0, 0, 11388, 11389, 7, 27, 0, 0, 11389, 11390, 7, 19, 0, + 0, 11390, 11391, 7, 15, 0, 0, 11391, 11392, 7, 12, 0, 0, 11392, 11393, + 7, 6, 0, 0, 11393, 1898, 1, 0, 0, 0, 11394, 11395, 7, 23, 0, 0, 11395, + 11396, 7, 16, 0, 0, 11396, 11397, 7, 8, 0, 0, 11397, 11398, 7, 7, 0, 0, + 11398, 11399, 7, 28, 0, 0, 11399, 11400, 7, 17, 0, 0, 11400, 11401, 7, + 3, 0, 0, 11401, 11402, 7, 5, 0, 0, 11402, 1900, 1, 0, 0, 0, 11403, 11404, + 7, 23, 0, 0, 11404, 11405, 7, 16, 0, 0, 11405, 11406, 7, 8, 0, 0, 11406, + 11407, 7, 15, 0, 0, 11407, 11408, 7, 12, 0, 0, 11408, 11409, 7, 6, 0, 0, + 11409, 11410, 7, 7, 0, 0, 11410, 11411, 7, 8, 0, 0, 11411, 11412, 7, 11, + 0, 0, 11412, 11413, 7, 7, 0, 0, 11413, 11414, 7, 14, 0, 0, 11414, 11415, + 7, 6, 0, 0, 11415, 11416, 7, 11, 0, 0, 11416, 1902, 1, 0, 0, 0, 11417, + 11418, 7, 23, 0, 0, 11418, 11419, 7, 16, 0, 0, 11419, 11420, 7, 8, 0, 0, + 11420, 11421, 7, 19, 0, 0, 11421, 11422, 7, 24, 0, 0, 11422, 11423, 7, + 7, 0, 0, 11423, 11424, 7, 8, 0, 0, 11424, 11425, 7, 5, 0, 0, 11425, 11426, + 7, 3, 0, 0, 11426, 11427, 7, 25, 0, 0, 11427, 11428, 7, 11, 0, 0, 11428, + 1904, 1, 0, 0, 0, 11429, 11430, 7, 23, 0, 0, 11430, 11431, 7, 16, 0, 0, + 11431, 11432, 7, 8, 0, 0, 11432, 11433, 7, 6, 0, 0, 11433, 11434, 7, 19, + 0, 0, 11434, 11435, 7, 17, 0, 0, 11435, 11436, 7, 14, 0, 0, 11436, 11437, + 7, 20, 0, 0, 11437, 11438, 7, 7, 0, 0, 11438, 11439, 7, 11, 0, 0, 11439, + 1906, 1, 0, 0, 0, 11440, 11441, 7, 23, 0, 0, 11441, 11442, 7, 16, 0, 0, + 11442, 11443, 7, 8, 0, 0, 11443, 11444, 7, 9, 0, 0, 11444, 11445, 7, 15, + 0, 0, 11445, 11446, 7, 6, 0, 0, 11446, 11447, 7, 20, 0, 0, 11447, 11448, + 7, 15, 0, 0, 11448, 11449, 7, 12, 0, 0, 11449, 1908, 1, 0, 0, 0, 11450, + 11451, 7, 23, 0, 0, 11451, 11452, 7, 4, 0, 0, 11452, 11453, 5, 53, 0, 0, + 11453, 1910, 1, 0, 0, 0, 11454, 11455, 7, 23, 0, 0, 11455, 11456, 7, 5, + 0, 0, 11456, 11457, 7, 15, 0, 0, 11457, 11458, 7, 12, 0, 0, 11458, 11459, + 7, 7, 0, 0, 11459, 11460, 7, 18, 0, 0, 11460, 11461, 7, 8, 0, 0, 11461, + 11462, 7, 19, 0, 0, 11462, 11463, 7, 23, 0, 0, 11463, 11464, 7, 6, 0, 0, + 11464, 11465, 7, 7, 0, 0, 11465, 11466, 7, 26, 0, 0, 11466, 11467, 7, 6, + 0, 0, 11467, 1912, 1, 0, 0, 0, 11468, 11469, 7, 23, 0, 0, 11469, 11470, + 7, 5, 0, 0, 11470, 11471, 7, 15, 0, 0, 11471, 11472, 7, 12, 0, 0, 11472, + 11473, 7, 7, 0, 0, 11473, 11474, 7, 18, 0, 0, 11474, 11475, 7, 8, 0, 0, + 11475, 11476, 7, 19, 0, 0, 11476, 11477, 7, 23, 0, 0, 11477, 11478, 7, + 9, 0, 0, 11478, 11479, 7, 21, 0, 0, 11479, 11480, 7, 16, 0, 0, 11480, 1914, + 1, 0, 0, 0, 11481, 11482, 7, 23, 0, 0, 11482, 11483, 7, 19, 0, 0, 11483, + 11484, 7, 12, 0, 0, 11484, 11485, 7, 6, 0, 0, 11485, 11486, 7, 20, 0, 0, + 11486, 11487, 7, 12, 0, 0, 11487, 11488, 7, 3, 0, 0, 11488, 11489, 7, 23, + 0, 0, 11489, 11490, 7, 7, 0, 0, 11490, 1916, 1, 0, 0, 0, 11491, 11492, + 7, 23, 0, 0, 11492, 11493, 7, 25, 0, 0, 11493, 11494, 7, 19, 0, 0, 11494, + 11495, 7, 15, 0, 0, 11495, 11496, 7, 12, 0, 0, 11496, 11497, 7, 6, 0, 0, + 11497, 11498, 7, 18, 0, 0, 11498, 11499, 7, 8, 0, 0, 11499, 11500, 7, 19, + 0, 0, 11500, 11501, 7, 23, 0, 0, 11501, 11502, 7, 6, 0, 0, 11502, 11503, + 7, 7, 0, 0, 11503, 11504, 7, 26, 0, 0, 11504, 11505, 7, 6, 0, 0, 11505, + 1918, 1, 0, 0, 0, 11506, 11507, 7, 23, 0, 0, 11507, 11508, 7, 25, 0, 0, + 11508, 11509, 7, 19, 0, 0, 11509, 11510, 7, 15, 0, 0, 11510, 11511, 7, + 12, 0, 0, 11511, 11512, 7, 6, 0, 0, 11512, 11513, 7, 18, 0, 0, 11513, 11514, + 7, 8, 0, 0, 11514, 11515, 7, 19, 0, 0, 11515, 11516, 7, 23, 0, 0, 11516, + 11517, 7, 9, 0, 0, 11517, 11518, 7, 21, 0, 0, 11518, 11519, 7, 16, 0, 0, + 11519, 1920, 1, 0, 0, 0, 11520, 11521, 7, 23, 0, 0, 11521, 11522, 7, 25, + 0, 0, 11522, 11523, 7, 19, 0, 0, 11523, 11524, 7, 5, 0, 0, 11524, 11525, + 7, 10, 0, 0, 11525, 11526, 7, 18, 0, 0, 11526, 11527, 7, 8, 0, 0, 11527, + 11528, 7, 19, 0, 0, 11528, 11529, 7, 23, 0, 0, 11529, 11530, 7, 6, 0, 0, + 11530, 11531, 7, 7, 0, 0, 11531, 11532, 7, 26, 0, 0, 11532, 11533, 7, 6, + 0, 0, 11533, 1922, 1, 0, 0, 0, 11534, 11535, 7, 23, 0, 0, 11535, 11536, + 7, 25, 0, 0, 11536, 11537, 7, 19, 0, 0, 11537, 11538, 7, 5, 0, 0, 11538, + 11539, 7, 10, 0, 0, 11539, 11540, 7, 18, 0, 0, 11540, 11541, 7, 8, 0, 0, + 11541, 11542, 7, 19, 0, 0, 11542, 11543, 7, 23, 0, 0, 11543, 11544, 7, + 9, 0, 0, 11544, 11545, 7, 21, 0, 0, 11545, 11546, 7, 16, 0, 0, 11546, 1924, + 1, 0, 0, 0, 11547, 11548, 7, 23, 0, 0, 11548, 11549, 7, 17, 0, 0, 11549, + 11550, 7, 5, 0, 0, 11550, 11551, 7, 6, 0, 0, 11551, 11552, 7, 15, 0, 0, + 11552, 11553, 7, 5, 0, 0, 11553, 11554, 7, 15, 0, 0, 11554, 11555, 7, 12, + 0, 0, 11555, 11556, 7, 7, 0, 0, 11556, 11557, 7, 11, 0, 0, 11557, 11558, + 7, 6, 0, 0, 11558, 11559, 7, 8, 0, 0, 11559, 11560, 7, 15, 0, 0, 11560, + 11561, 7, 12, 0, 0, 11561, 11562, 7, 22, 0, 0, 11562, 11563, 7, 18, 0, + 0, 11563, 11564, 7, 8, 0, 0, 11564, 11565, 7, 19, 0, 0, 11565, 11566, 7, + 23, 0, 0, 11566, 11567, 7, 6, 0, 0, 11567, 11568, 7, 7, 0, 0, 11568, 11569, + 7, 26, 0, 0, 11569, 11570, 7, 6, 0, 0, 11570, 1926, 1, 0, 0, 0, 11571, + 11572, 7, 23, 0, 0, 11572, 11573, 7, 17, 0, 0, 11573, 11574, 7, 5, 0, 0, + 11574, 11575, 7, 6, 0, 0, 11575, 11576, 7, 15, 0, 0, 11576, 11577, 7, 5, + 0, 0, 11577, 11578, 7, 15, 0, 0, 11578, 11579, 7, 12, 0, 0, 11579, 11580, + 7, 7, 0, 0, 11580, 11581, 7, 11, 0, 0, 11581, 11582, 7, 6, 0, 0, 11582, + 11583, 7, 8, 0, 0, 11583, 11584, 7, 15, 0, 0, 11584, 11585, 7, 12, 0, 0, + 11585, 11586, 7, 22, 0, 0, 11586, 11587, 7, 18, 0, 0, 11587, 11588, 7, + 8, 0, 0, 11588, 11589, 7, 19, 0, 0, 11589, 11590, 7, 23, 0, 0, 11590, 11591, + 7, 9, 0, 0, 11591, 11592, 7, 21, 0, 0, 11592, 11593, 7, 16, 0, 0, 11593, + 1928, 1, 0, 0, 0, 11594, 11595, 7, 23, 0, 0, 11595, 11596, 7, 17, 0, 0, + 11596, 11597, 7, 5, 0, 0, 11597, 11598, 7, 6, 0, 0, 11598, 11599, 7, 15, + 0, 0, 11599, 11600, 7, 25, 0, 0, 11600, 11601, 7, 19, 0, 0, 11601, 11602, + 7, 15, 0, 0, 11602, 11603, 7, 12, 0, 0, 11603, 11604, 7, 6, 0, 0, 11604, + 11605, 7, 18, 0, 0, 11605, 11606, 7, 8, 0, 0, 11606, 11607, 7, 19, 0, 0, + 11607, 11608, 7, 23, 0, 0, 11608, 11609, 7, 6, 0, 0, 11609, 11610, 7, 7, + 0, 0, 11610, 11611, 7, 26, 0, 0, 11611, 11612, 7, 6, 0, 0, 11612, 1930, + 1, 0, 0, 0, 11613, 11614, 7, 23, 0, 0, 11614, 11615, 7, 17, 0, 0, 11615, + 11616, 7, 5, 0, 0, 11616, 11617, 7, 6, 0, 0, 11617, 11618, 7, 15, 0, 0, + 11618, 11619, 7, 25, 0, 0, 11619, 11620, 7, 19, 0, 0, 11620, 11621, 7, + 15, 0, 0, 11621, 11622, 7, 12, 0, 0, 11622, 11623, 7, 6, 0, 0, 11623, 11624, + 7, 18, 0, 0, 11624, 11625, 7, 8, 0, 0, 11625, 11626, 7, 19, 0, 0, 11626, + 11627, 7, 23, 0, 0, 11627, 11628, 7, 9, 0, 0, 11628, 11629, 7, 21, 0, 0, + 11629, 11630, 7, 16, 0, 0, 11630, 1932, 1, 0, 0, 0, 11631, 11632, 7, 23, + 0, 0, 11632, 11633, 7, 17, 0, 0, 11633, 11634, 7, 5, 0, 0, 11634, 11635, + 7, 6, 0, 0, 11635, 11636, 7, 15, 0, 0, 11636, 11637, 7, 25, 0, 0, 11637, + 11638, 7, 19, 0, 0, 11638, 11639, 7, 5, 0, 0, 11639, 11640, 7, 10, 0, 0, + 11640, 11641, 7, 22, 0, 0, 11641, 11642, 7, 19, 0, 0, 11642, 11643, 7, + 12, 0, 0, 11643, 11644, 7, 18, 0, 0, 11644, 11645, 7, 8, 0, 0, 11645, 11646, + 7, 19, 0, 0, 11646, 11647, 7, 23, 0, 0, 11647, 11648, 7, 6, 0, 0, 11648, + 11649, 7, 7, 0, 0, 11649, 11650, 7, 26, 0, 0, 11650, 11651, 7, 6, 0, 0, + 11651, 1934, 1, 0, 0, 0, 11652, 11653, 7, 23, 0, 0, 11653, 11654, 7, 17, + 0, 0, 11654, 11655, 7, 5, 0, 0, 11655, 11656, 7, 6, 0, 0, 11656, 11657, + 7, 15, 0, 0, 11657, 11658, 7, 25, 0, 0, 11658, 11659, 7, 19, 0, 0, 11659, + 11660, 7, 5, 0, 0, 11660, 11661, 7, 10, 0, 0, 11661, 11662, 7, 22, 0, 0, + 11662, 11663, 7, 19, 0, 0, 11663, 11664, 7, 12, 0, 0, 11664, 11665, 7, + 18, 0, 0, 11665, 11666, 7, 8, 0, 0, 11666, 11667, 7, 19, 0, 0, 11667, 11668, + 7, 23, 0, 0, 11668, 11669, 7, 9, 0, 0, 11669, 11670, 7, 21, 0, 0, 11670, + 11671, 7, 16, 0, 0, 11671, 1936, 1, 0, 0, 0, 11672, 11673, 7, 12, 0, 0, + 11673, 11674, 7, 3, 0, 0, 11674, 11675, 7, 23, 0, 0, 11675, 11676, 7, 7, + 0, 0, 11676, 11677, 5, 95, 0, 0, 11677, 11678, 7, 14, 0, 0, 11678, 11679, + 7, 19, 0, 0, 11679, 11680, 7, 12, 0, 0, 11680, 11681, 7, 11, 0, 0, 11681, + 11682, 7, 6, 0, 0, 11682, 1938, 1, 0, 0, 0, 11683, 11684, 7, 12, 0, 0, + 11684, 11685, 7, 17, 0, 0, 11685, 11686, 7, 5, 0, 0, 11686, 11687, 7, 5, + 0, 0, 11687, 11688, 7, 15, 0, 0, 11688, 11689, 7, 18, 0, 0, 11689, 1940, + 1, 0, 0, 0, 11690, 11691, 7, 12, 0, 0, 11691, 11692, 7, 17, 0, 0, 11692, + 11693, 7, 23, 0, 0, 11693, 11694, 7, 22, 0, 0, 11694, 11695, 7, 7, 0, 0, + 11695, 11696, 7, 19, 0, 0, 11696, 11697, 7, 23, 0, 0, 11697, 11698, 7, + 7, 0, 0, 11698, 11699, 7, 6, 0, 0, 11699, 11700, 7, 8, 0, 0, 11700, 11701, + 7, 15, 0, 0, 11701, 11702, 7, 7, 0, 0, 11702, 11703, 7, 11, 0, 0, 11703, + 1942, 1, 0, 0, 0, 11704, 11705, 7, 12, 0, 0, 11705, 11706, 7, 17, 0, 0, + 11706, 11707, 7, 23, 0, 0, 11707, 11708, 7, 15, 0, 0, 11708, 11709, 7, + 12, 0, 0, 11709, 11710, 7, 6, 0, 0, 11710, 11711, 7, 7, 0, 0, 11711, 11712, + 7, 8, 0, 0, 11712, 11713, 7, 15, 0, 0, 11713, 11714, 7, 19, 0, 0, 11714, + 11715, 7, 8, 0, 0, 11715, 11716, 7, 8, 0, 0, 11716, 11717, 7, 15, 0, 0, + 11717, 11718, 7, 12, 0, 0, 11718, 11719, 7, 22, 0, 0, 11719, 11720, 7, + 11, 0, 0, 11720, 1944, 1, 0, 0, 0, 11721, 11722, 7, 12, 0, 0, 11722, 11723, + 7, 17, 0, 0, 11723, 11724, 7, 23, 0, 0, 11724, 11725, 7, 25, 0, 0, 11725, + 11726, 7, 19, 0, 0, 11726, 11727, 7, 15, 0, 0, 11727, 11728, 7, 12, 0, + 0, 11728, 11729, 7, 6, 0, 0, 11729, 11730, 7, 11, 0, 0, 11730, 1946, 1, + 0, 0, 0, 11731, 11732, 7, 19, 0, 0, 11732, 11733, 7, 14, 0, 0, 11733, 11734, + 7, 6, 0, 0, 11734, 1948, 1, 0, 0, 0, 11735, 11736, 7, 19, 0, 0, 11736, + 11737, 7, 14, 0, 0, 11737, 11738, 7, 6, 0, 0, 11738, 11739, 7, 7, 0, 0, + 11739, 11740, 7, 6, 0, 0, 11740, 11741, 5, 95, 0, 0, 11741, 11742, 7, 5, + 0, 0, 11742, 11743, 7, 7, 0, 0, 11743, 11744, 7, 12, 0, 0, 11744, 11745, + 7, 22, 0, 0, 11745, 11746, 7, 6, 0, 0, 11746, 11747, 7, 20, 0, 0, 11747, + 1950, 1, 0, 0, 0, 11748, 11749, 7, 19, 0, 0, 11749, 11750, 7, 8, 0, 0, + 11750, 11751, 7, 4, 0, 0, 11751, 1952, 1, 0, 0, 0, 11752, 11753, 7, 19, + 0, 0, 11753, 11754, 7, 24, 0, 0, 11754, 11755, 7, 7, 0, 0, 11755, 11756, + 7, 8, 0, 0, 11756, 11757, 7, 5, 0, 0, 11757, 11758, 7, 3, 0, 0, 11758, + 11759, 7, 25, 0, 0, 11759, 11760, 7, 11, 0, 0, 11760, 1954, 1, 0, 0, 0, + 11761, 11762, 7, 25, 0, 0, 11762, 11763, 7, 7, 0, 0, 11763, 11764, 7, 8, + 0, 0, 11764, 11765, 7, 15, 0, 0, 11765, 11766, 7, 19, 0, 0, 11766, 11767, + 7, 4, 0, 0, 11767, 11768, 5, 95, 0, 0, 11768, 11769, 7, 3, 0, 0, 11769, + 11770, 7, 4, 0, 0, 11770, 11771, 7, 4, 0, 0, 11771, 1956, 1, 0, 0, 0, 11772, + 11773, 7, 25, 0, 0, 11773, 11774, 7, 7, 0, 0, 11774, 11775, 7, 8, 0, 0, + 11775, 11776, 7, 15, 0, 0, 11776, 11777, 7, 19, 0, 0, 11777, 11778, 7, + 4, 0, 0, 11778, 11779, 5, 95, 0, 0, 11779, 11780, 7, 4, 0, 0, 11780, 11781, + 7, 15, 0, 0, 11781, 11782, 7, 18, 0, 0, 11782, 11783, 7, 18, 0, 0, 11783, + 1958, 1, 0, 0, 0, 11784, 11785, 7, 25, 0, 0, 11785, 11786, 7, 15, 0, 0, + 11786, 1960, 1, 0, 0, 0, 11787, 11788, 7, 25, 0, 0, 11788, 11789, 7, 19, + 0, 0, 11789, 11790, 7, 15, 0, 0, 11790, 11791, 7, 12, 0, 0, 11791, 11792, + 7, 6, 0, 0, 11792, 11793, 7, 18, 0, 0, 11793, 11794, 7, 8, 0, 0, 11794, + 11795, 7, 19, 0, 0, 11795, 11796, 7, 23, 0, 0, 11796, 11797, 7, 6, 0, 0, + 11797, 11798, 7, 7, 0, 0, 11798, 11799, 7, 26, 0, 0, 11799, 11800, 7, 6, + 0, 0, 11800, 1962, 1, 0, 0, 0, 11801, 11802, 7, 25, 0, 0, 11802, 11803, + 7, 19, 0, 0, 11803, 11804, 7, 15, 0, 0, 11804, 11805, 7, 12, 0, 0, 11805, + 11806, 7, 6, 0, 0, 11806, 11807, 7, 18, 0, 0, 11807, 11808, 7, 8, 0, 0, + 11808, 11809, 7, 19, 0, 0, 11809, 11810, 7, 23, 0, 0, 11810, 11811, 7, + 9, 0, 0, 11811, 11812, 7, 21, 0, 0, 11812, 11813, 7, 16, 0, 0, 11813, 1964, + 1, 0, 0, 0, 11814, 11815, 7, 25, 0, 0, 11815, 11816, 7, 19, 0, 0, 11816, + 11817, 7, 15, 0, 0, 11817, 11818, 7, 12, 0, 0, 11818, 11819, 7, 6, 0, 0, + 11819, 11820, 7, 12, 0, 0, 11820, 1966, 1, 0, 0, 0, 11821, 11822, 7, 25, + 0, 0, 11822, 11823, 7, 19, 0, 0, 11823, 11824, 7, 5, 0, 0, 11824, 11825, + 7, 10, 0, 0, 11825, 11826, 7, 18, 0, 0, 11826, 11827, 7, 8, 0, 0, 11827, + 11828, 7, 19, 0, 0, 11828, 11829, 7, 23, 0, 0, 11829, 11830, 7, 6, 0, 0, + 11830, 11831, 7, 7, 0, 0, 11831, 11832, 7, 26, 0, 0, 11832, 11833, 7, 6, + 0, 0, 11833, 1968, 1, 0, 0, 0, 11834, 11835, 7, 25, 0, 0, 11835, 11836, + 7, 19, 0, 0, 11836, 11837, 7, 5, 0, 0, 11837, 11838, 7, 10, 0, 0, 11838, + 11839, 7, 18, 0, 0, 11839, 11840, 7, 8, 0, 0, 11840, 11841, 7, 19, 0, 0, + 11841, 11842, 7, 23, 0, 0, 11842, 11843, 7, 9, 0, 0, 11843, 11844, 7, 21, + 0, 0, 11844, 11845, 7, 16, 0, 0, 11845, 1970, 1, 0, 0, 0, 11846, 11847, + 7, 25, 0, 0, 11847, 11848, 7, 19, 0, 0, 11848, 11849, 7, 5, 0, 0, 11849, + 11850, 7, 10, 0, 0, 11850, 11851, 7, 22, 0, 0, 11851, 11852, 7, 19, 0, + 0, 11852, 11853, 7, 12, 0, 0, 11853, 11854, 7, 18, 0, 0, 11854, 11855, + 7, 8, 0, 0, 11855, 11856, 7, 19, 0, 0, 11856, 11857, 7, 23, 0, 0, 11857, + 11858, 7, 6, 0, 0, 11858, 11859, 7, 7, 0, 0, 11859, 11860, 7, 26, 0, 0, + 11860, 11861, 7, 6, 0, 0, 11861, 1972, 1, 0, 0, 0, 11862, 11863, 7, 25, + 0, 0, 11863, 11864, 7, 19, 0, 0, 11864, 11865, 7, 5, 0, 0, 11865, 11866, + 7, 10, 0, 0, 11866, 11867, 7, 22, 0, 0, 11867, 11868, 7, 19, 0, 0, 11868, + 11869, 7, 12, 0, 0, 11869, 11870, 7, 18, 0, 0, 11870, 11871, 7, 8, 0, 0, + 11871, 11872, 7, 19, 0, 0, 11872, 11873, 7, 23, 0, 0, 11873, 11874, 7, + 9, 0, 0, 11874, 11875, 7, 21, 0, 0, 11875, 11876, 7, 16, 0, 0, 11876, 1974, + 1, 0, 0, 0, 11877, 11878, 7, 25, 0, 0, 11878, 11879, 7, 19, 0, 0, 11879, + 11880, 7, 9, 0, 0, 11880, 1976, 1, 0, 0, 0, 11881, 11882, 7, 25, 0, 0, + 11882, 11883, 7, 19, 0, 0, 11883, 11884, 7, 9, 0, 0, 11884, 11885, 7, 7, + 0, 0, 11885, 11886, 7, 8, 0, 0, 11886, 1978, 1, 0, 0, 0, 11887, 11888, + 7, 28, 0, 0, 11888, 11889, 7, 17, 0, 0, 11889, 11890, 7, 19, 0, 0, 11890, + 11891, 7, 6, 0, 0, 11891, 11892, 7, 7, 0, 0, 11892, 1980, 1, 0, 0, 0, 11893, + 11894, 7, 8, 0, 0, 11894, 11895, 7, 3, 0, 0, 11895, 11896, 7, 4, 0, 0, + 11896, 11897, 7, 15, 0, 0, 11897, 11898, 7, 3, 0, 0, 11898, 11899, 7, 12, + 0, 0, 11899, 11900, 7, 11, 0, 0, 11900, 1982, 1, 0, 0, 0, 11901, 11902, + 7, 8, 0, 0, 11902, 11903, 7, 3, 0, 0, 11903, 11904, 7, 12, 0, 0, 11904, + 11905, 7, 4, 0, 0, 11905, 1984, 1, 0, 0, 0, 11906, 11907, 7, 8, 0, 0, 11907, + 11908, 7, 3, 0, 0, 11908, 11909, 7, 12, 0, 0, 11909, 11910, 7, 4, 0, 0, + 11910, 11911, 7, 19, 0, 0, 11911, 11912, 7, 23, 0, 0, 11912, 1986, 1, 0, + 0, 0, 11913, 11914, 7, 8, 0, 0, 11914, 11915, 7, 3, 0, 0, 11915, 11916, + 7, 12, 0, 0, 11916, 11917, 7, 4, 0, 0, 11917, 11918, 7, 19, 0, 0, 11918, + 11919, 7, 23, 0, 0, 11919, 11920, 5, 95, 0, 0, 11920, 11921, 7, 16, 0, + 0, 11921, 11922, 7, 10, 0, 0, 11922, 11923, 7, 6, 0, 0, 11923, 11924, 7, + 7, 0, 0, 11924, 11925, 7, 11, 0, 0, 11925, 1988, 1, 0, 0, 0, 11926, 11927, + 7, 8, 0, 0, 11927, 11928, 7, 7, 0, 0, 11928, 11929, 7, 5, 0, 0, 11929, + 11930, 7, 7, 0, 0, 11930, 11931, 7, 3, 0, 0, 11931, 11932, 7, 11, 0, 0, + 11932, 11933, 7, 7, 0, 0, 11933, 11934, 5, 95, 0, 0, 11934, 11935, 7, 5, + 0, 0, 11935, 11936, 7, 19, 0, 0, 11936, 11937, 7, 14, 0, 0, 11937, 11938, + 7, 21, 0, 0, 11938, 1990, 1, 0, 0, 0, 11939, 11940, 7, 8, 0, 0, 11940, + 11941, 7, 7, 0, 0, 11941, 11942, 7, 24, 0, 0, 11942, 11943, 7, 7, 0, 0, + 11943, 11944, 7, 8, 0, 0, 11944, 11945, 7, 11, 0, 0, 11945, 11946, 7, 7, + 0, 0, 11946, 1992, 1, 0, 0, 0, 11947, 11948, 7, 8, 0, 0, 11948, 11949, + 7, 19, 0, 0, 11949, 11950, 7, 17, 0, 0, 11950, 11951, 7, 12, 0, 0, 11951, + 11952, 7, 4, 0, 0, 11952, 1994, 1, 0, 0, 0, 11953, 11954, 7, 8, 0, 0, 11954, + 11955, 7, 19, 0, 0, 11955, 11956, 7, 9, 0, 0, 11956, 11957, 5, 95, 0, 0, + 11957, 11958, 7, 14, 0, 0, 11958, 11959, 7, 19, 0, 0, 11959, 11960, 7, + 17, 0, 0, 11960, 11961, 7, 12, 0, 0, 11961, 11962, 7, 6, 0, 0, 11962, 1996, + 1, 0, 0, 0, 11963, 11964, 7, 8, 0, 0, 11964, 11965, 7, 25, 0, 0, 11965, + 11966, 7, 3, 0, 0, 11966, 11967, 7, 4, 0, 0, 11967, 1998, 1, 0, 0, 0, 11968, + 11969, 7, 8, 0, 0, 11969, 11970, 7, 6, 0, 0, 11970, 11971, 7, 8, 0, 0, + 11971, 11972, 7, 15, 0, 0, 11972, 11973, 7, 23, 0, 0, 11973, 2000, 1, 0, + 0, 0, 11974, 11975, 7, 11, 0, 0, 11975, 11976, 7, 7, 0, 0, 11976, 11977, + 7, 14, 0, 0, 11977, 11978, 5, 95, 0, 0, 11978, 11979, 7, 6, 0, 0, 11979, + 11980, 7, 19, 0, 0, 11980, 11981, 5, 95, 0, 0, 11981, 11982, 7, 6, 0, 0, + 11982, 11983, 7, 15, 0, 0, 11983, 11984, 7, 23, 0, 0, 11984, 11985, 7, + 7, 0, 0, 11985, 2002, 1, 0, 0, 0, 11986, 11987, 7, 11, 0, 0, 11987, 11988, + 7, 7, 0, 0, 11988, 11989, 7, 14, 0, 0, 11989, 11990, 7, 19, 0, 0, 11990, + 11991, 7, 12, 0, 0, 11991, 11992, 7, 4, 0, 0, 11992, 11993, 7, 3, 0, 0, + 11993, 11994, 7, 8, 0, 0, 11994, 11995, 7, 10, 0, 0, 11995, 11996, 5, 95, + 0, 0, 11996, 11997, 7, 7, 0, 0, 11997, 11998, 7, 12, 0, 0, 11998, 11999, + 7, 22, 0, 0, 11999, 12000, 7, 15, 0, 0, 12000, 12001, 7, 12, 0, 0, 12001, + 12002, 7, 7, 0, 0, 12002, 12003, 5, 95, 0, 0, 12003, 12004, 7, 3, 0, 0, + 12004, 12005, 7, 6, 0, 0, 12005, 12006, 7, 6, 0, 0, 12006, 12007, 7, 8, + 0, 0, 12007, 12008, 7, 15, 0, 0, 12008, 12009, 7, 16, 0, 0, 12009, 12010, + 7, 17, 0, 0, 12010, 12011, 7, 6, 0, 0, 12011, 12012, 7, 7, 0, 0, 12012, + 2004, 1, 0, 0, 0, 12013, 12014, 7, 11, 0, 0, 12014, 12015, 7, 7, 0, 0, + 12015, 12016, 7, 11, 0, 0, 12016, 12017, 7, 11, 0, 0, 12017, 12018, 7, + 15, 0, 0, 12018, 12019, 7, 19, 0, 0, 12019, 12020, 7, 12, 0, 0, 12020, + 12021, 5, 95, 0, 0, 12021, 12022, 7, 17, 0, 0, 12022, 12023, 7, 11, 0, + 0, 12023, 12024, 7, 7, 0, 0, 12024, 12025, 7, 8, 0, 0, 12025, 2006, 1, + 0, 0, 0, 12026, 12027, 7, 11, 0, 0, 12027, 12028, 7, 20, 0, 0, 12028, 12029, + 7, 3, 0, 0, 12029, 2008, 1, 0, 0, 0, 12030, 12031, 7, 11, 0, 0, 12031, + 12032, 7, 20, 0, 0, 12032, 12033, 7, 3, 0, 0, 12033, 12034, 5, 49, 0, 0, + 12034, 2010, 1, 0, 0, 0, 12035, 12036, 7, 11, 0, 0, 12036, 12037, 7, 20, + 0, 0, 12037, 12038, 7, 3, 0, 0, 12038, 12039, 5, 50, 0, 0, 12039, 2012, + 1, 0, 0, 0, 12040, 12041, 7, 11, 0, 0, 12041, 12042, 7, 14, 0, 0, 12042, + 12043, 7, 20, 0, 0, 12043, 12044, 7, 7, 0, 0, 12044, 12045, 7, 23, 0, 0, + 12045, 12046, 7, 3, 0, 0, 12046, 12047, 5, 95, 0, 0, 12047, 12048, 7, 12, + 0, 0, 12048, 12049, 7, 3, 0, 0, 12049, 12050, 7, 23, 0, 0, 12050, 12051, + 7, 7, 0, 0, 12051, 2014, 1, 0, 0, 0, 12052, 12053, 7, 11, 0, 0, 12053, + 12054, 7, 15, 0, 0, 12054, 12055, 7, 22, 0, 0, 12055, 12056, 7, 12, 0, + 0, 12056, 2016, 1, 0, 0, 0, 12057, 12058, 7, 11, 0, 0, 12058, 12059, 7, + 15, 0, 0, 12059, 12060, 7, 12, 0, 0, 12060, 2018, 1, 0, 0, 0, 12061, 12062, + 7, 11, 0, 0, 12062, 12063, 7, 5, 0, 0, 12063, 12064, 7, 7, 0, 0, 12064, + 12065, 7, 7, 0, 0, 12065, 12066, 7, 25, 0, 0, 12066, 2020, 1, 0, 0, 0, + 12067, 12068, 7, 11, 0, 0, 12068, 12069, 7, 19, 0, 0, 12069, 12070, 7, + 17, 0, 0, 12070, 12071, 7, 12, 0, 0, 12071, 12072, 7, 4, 0, 0, 12072, 12073, + 7, 7, 0, 0, 12073, 12074, 7, 26, 0, 0, 12074, 2022, 1, 0, 0, 0, 12075, + 12076, 7, 11, 0, 0, 12076, 12077, 7, 28, 0, 0, 12077, 12078, 7, 5, 0, 0, + 12078, 12079, 5, 95, 0, 0, 12079, 12080, 7, 6, 0, 0, 12080, 12081, 7, 20, + 0, 0, 12081, 12082, 7, 8, 0, 0, 12082, 12083, 7, 7, 0, 0, 12083, 12084, + 7, 3, 0, 0, 12084, 12085, 7, 4, 0, 0, 12085, 12086, 5, 95, 0, 0, 12086, + 12087, 7, 9, 0, 0, 12087, 12088, 7, 3, 0, 0, 12088, 12089, 7, 15, 0, 0, + 12089, 12090, 7, 6, 0, 0, 12090, 12091, 5, 95, 0, 0, 12091, 12092, 7, 3, + 0, 0, 12092, 12093, 7, 18, 0, 0, 12093, 12094, 7, 6, 0, 0, 12094, 12095, + 7, 7, 0, 0, 12095, 12096, 7, 8, 0, 0, 12096, 12097, 5, 95, 0, 0, 12097, + 12098, 7, 22, 0, 0, 12098, 12099, 7, 6, 0, 0, 12099, 12100, 7, 15, 0, 0, + 12100, 12101, 7, 4, 0, 0, 12101, 12102, 7, 11, 0, 0, 12102, 2024, 1, 0, + 0, 0, 12103, 12104, 7, 11, 0, 0, 12104, 12105, 7, 28, 0, 0, 12105, 12106, + 7, 8, 0, 0, 12106, 12107, 7, 6, 0, 0, 12107, 2026, 1, 0, 0, 0, 12108, 12109, + 7, 11, 0, 0, 12109, 12110, 7, 8, 0, 0, 12110, 12111, 7, 15, 0, 0, 12111, + 12112, 7, 4, 0, 0, 12112, 2028, 1, 0, 0, 0, 12113, 12114, 7, 11, 0, 0, + 12114, 12115, 7, 6, 0, 0, 12115, 12116, 7, 3, 0, 0, 12116, 12117, 7, 8, + 0, 0, 12117, 12118, 7, 6, 0, 0, 12118, 12119, 7, 25, 0, 0, 12119, 12120, + 7, 19, 0, 0, 12120, 12121, 7, 15, 0, 0, 12121, 12122, 7, 12, 0, 0, 12122, + 12123, 7, 6, 0, 0, 12123, 2030, 1, 0, 0, 0, 12124, 12125, 7, 11, 0, 0, + 12125, 12126, 7, 6, 0, 0, 12126, 12127, 7, 8, 0, 0, 12127, 12128, 7, 14, + 0, 0, 12128, 12129, 7, 23, 0, 0, 12129, 12130, 7, 25, 0, 0, 12130, 2032, + 1, 0, 0, 0, 12131, 12132, 7, 11, 0, 0, 12132, 12133, 7, 6, 0, 0, 12133, + 12134, 7, 8, 0, 0, 12134, 12135, 5, 95, 0, 0, 12135, 12136, 7, 6, 0, 0, + 12136, 12137, 7, 19, 0, 0, 12137, 12138, 5, 95, 0, 0, 12138, 12139, 7, + 4, 0, 0, 12139, 12140, 7, 3, 0, 0, 12140, 12141, 7, 6, 0, 0, 12141, 12142, + 7, 7, 0, 0, 12142, 2034, 1, 0, 0, 0, 12143, 12144, 7, 11, 0, 0, 12144, + 12145, 7, 6, 0, 0, 12145, 12146, 5, 95, 0, 0, 12146, 12147, 7, 3, 0, 0, + 12147, 12148, 7, 8, 0, 0, 12148, 12149, 7, 7, 0, 0, 12149, 12150, 7, 3, + 0, 0, 12150, 2036, 1, 0, 0, 0, 12151, 12152, 7, 11, 0, 0, 12152, 12153, + 7, 6, 0, 0, 12153, 12154, 5, 95, 0, 0, 12154, 12155, 7, 3, 0, 0, 12155, + 12156, 7, 11, 0, 0, 12156, 12157, 7, 16, 0, 0, 12157, 12158, 7, 15, 0, + 0, 12158, 12159, 7, 12, 0, 0, 12159, 12160, 7, 3, 0, 0, 12160, 12161, 7, + 8, 0, 0, 12161, 12162, 7, 10, 0, 0, 12162, 2038, 1, 0, 0, 0, 12163, 12164, + 7, 11, 0, 0, 12164, 12165, 7, 6, 0, 0, 12165, 12166, 5, 95, 0, 0, 12166, + 12167, 7, 3, 0, 0, 12167, 12168, 7, 11, 0, 0, 12168, 12169, 7, 6, 0, 0, + 12169, 12170, 7, 7, 0, 0, 12170, 12171, 7, 26, 0, 0, 12171, 12172, 7, 6, + 0, 0, 12172, 2040, 1, 0, 0, 0, 12173, 12174, 7, 11, 0, 0, 12174, 12175, + 7, 6, 0, 0, 12175, 12176, 5, 95, 0, 0, 12176, 12177, 7, 3, 0, 0, 12177, + 12178, 7, 11, 0, 0, 12178, 12179, 7, 9, 0, 0, 12179, 12180, 7, 21, 0, 0, + 12180, 12181, 7, 16, 0, 0, 12181, 2042, 1, 0, 0, 0, 12182, 12183, 7, 11, + 0, 0, 12183, 12184, 7, 6, 0, 0, 12184, 12185, 5, 95, 0, 0, 12185, 12186, + 7, 3, 0, 0, 12186, 12187, 7, 11, 0, 0, 12187, 12188, 7, 9, 0, 0, 12188, + 12189, 7, 21, 0, 0, 12189, 12190, 7, 6, 0, 0, 12190, 2044, 1, 0, 0, 0, + 12191, 12192, 7, 11, 0, 0, 12192, 12193, 7, 6, 0, 0, 12193, 12194, 5, 95, + 0, 0, 12194, 12195, 7, 16, 0, 0, 12195, 12196, 7, 17, 0, 0, 12196, 12197, + 7, 18, 0, 0, 12197, 12198, 7, 18, 0, 0, 12198, 12199, 7, 7, 0, 0, 12199, + 12200, 7, 8, 0, 0, 12200, 2046, 1, 0, 0, 0, 12201, 12202, 7, 11, 0, 0, + 12202, 12203, 7, 6, 0, 0, 12203, 12204, 5, 95, 0, 0, 12204, 12205, 7, 14, + 0, 0, 12205, 12206, 7, 7, 0, 0, 12206, 12207, 7, 12, 0, 0, 12207, 12208, + 7, 6, 0, 0, 12208, 12209, 7, 8, 0, 0, 12209, 12210, 7, 19, 0, 0, 12210, + 12211, 7, 15, 0, 0, 12211, 12212, 7, 4, 0, 0, 12212, 2048, 1, 0, 0, 0, + 12213, 12214, 7, 11, 0, 0, 12214, 12215, 7, 6, 0, 0, 12215, 12216, 5, 95, + 0, 0, 12216, 12217, 7, 14, 0, 0, 12217, 12218, 7, 19, 0, 0, 12218, 12219, + 7, 12, 0, 0, 12219, 12220, 7, 6, 0, 0, 12220, 12221, 7, 3, 0, 0, 12221, + 12222, 7, 15, 0, 0, 12222, 12223, 7, 12, 0, 0, 12223, 12224, 7, 11, 0, + 0, 12224, 2050, 1, 0, 0, 0, 12225, 12226, 7, 11, 0, 0, 12226, 12227, 7, + 6, 0, 0, 12227, 12228, 5, 95, 0, 0, 12228, 12229, 7, 14, 0, 0, 12229, 12230, + 7, 8, 0, 0, 12230, 12231, 7, 19, 0, 0, 12231, 12232, 7, 11, 0, 0, 12232, + 12233, 7, 11, 0, 0, 12233, 12234, 7, 7, 0, 0, 12234, 12235, 7, 11, 0, 0, + 12235, 2052, 1, 0, 0, 0, 12236, 12237, 7, 11, 0, 0, 12237, 12238, 7, 6, + 0, 0, 12238, 12239, 5, 95, 0, 0, 12239, 12240, 7, 4, 0, 0, 12240, 12241, + 7, 15, 0, 0, 12241, 12242, 7, 18, 0, 0, 12242, 12243, 7, 18, 0, 0, 12243, + 12244, 7, 7, 0, 0, 12244, 12245, 7, 8, 0, 0, 12245, 12246, 7, 7, 0, 0, + 12246, 12247, 7, 12, 0, 0, 12247, 12248, 7, 14, 0, 0, 12248, 12249, 7, + 7, 0, 0, 12249, 2054, 1, 0, 0, 0, 12250, 12251, 7, 11, 0, 0, 12251, 12252, + 7, 6, 0, 0, 12252, 12253, 5, 95, 0, 0, 12253, 12254, 7, 4, 0, 0, 12254, + 12255, 7, 15, 0, 0, 12255, 12256, 7, 23, 0, 0, 12256, 12257, 7, 7, 0, 0, + 12257, 12258, 7, 12, 0, 0, 12258, 12259, 7, 11, 0, 0, 12259, 12260, 7, + 15, 0, 0, 12260, 12261, 7, 19, 0, 0, 12261, 12262, 7, 12, 0, 0, 12262, + 2056, 1, 0, 0, 0, 12263, 12264, 7, 11, 0, 0, 12264, 12265, 7, 6, 0, 0, + 12265, 12266, 5, 95, 0, 0, 12266, 12267, 7, 4, 0, 0, 12267, 12268, 7, 15, + 0, 0, 12268, 12269, 7, 11, 0, 0, 12269, 12270, 7, 27, 0, 0, 12270, 12271, + 7, 19, 0, 0, 12271, 12272, 7, 15, 0, 0, 12272, 12273, 7, 12, 0, 0, 12273, + 12274, 7, 6, 0, 0, 12274, 2058, 1, 0, 0, 0, 12275, 12276, 7, 11, 0, 0, + 12276, 12277, 7, 6, 0, 0, 12277, 12278, 5, 95, 0, 0, 12278, 12279, 7, 4, + 0, 0, 12279, 12280, 7, 15, 0, 0, 12280, 12281, 7, 11, 0, 0, 12281, 12282, + 7, 6, 0, 0, 12282, 12283, 7, 3, 0, 0, 12283, 12284, 7, 12, 0, 0, 12284, + 12285, 7, 14, 0, 0, 12285, 12286, 7, 7, 0, 0, 12286, 2060, 1, 0, 0, 0, + 12287, 12288, 7, 11, 0, 0, 12288, 12289, 7, 6, 0, 0, 12289, 12290, 5, 95, + 0, 0, 12290, 12291, 7, 7, 0, 0, 12291, 12292, 7, 12, 0, 0, 12292, 12293, + 7, 4, 0, 0, 12293, 12294, 7, 25, 0, 0, 12294, 12295, 7, 19, 0, 0, 12295, + 12296, 7, 15, 0, 0, 12296, 12297, 7, 12, 0, 0, 12297, 12298, 7, 6, 0, 0, + 12298, 2062, 1, 0, 0, 0, 12299, 12300, 7, 11, 0, 0, 12300, 12301, 7, 6, + 0, 0, 12301, 12302, 5, 95, 0, 0, 12302, 12303, 7, 7, 0, 0, 12303, 12304, + 7, 12, 0, 0, 12304, 12305, 7, 24, 0, 0, 12305, 12306, 7, 7, 0, 0, 12306, + 12307, 7, 5, 0, 0, 12307, 12308, 7, 19, 0, 0, 12308, 12309, 7, 25, 0, 0, + 12309, 12310, 7, 7, 0, 0, 12310, 2064, 1, 0, 0, 0, 12311, 12312, 7, 11, + 0, 0, 12312, 12313, 7, 6, 0, 0, 12313, 12314, 5, 95, 0, 0, 12314, 12315, + 7, 7, 0, 0, 12315, 12316, 7, 28, 0, 0, 12316, 12317, 7, 17, 0, 0, 12317, + 12318, 7, 3, 0, 0, 12318, 12319, 7, 5, 0, 0, 12319, 12320, 7, 11, 0, 0, + 12320, 2066, 1, 0, 0, 0, 12321, 12322, 7, 11, 0, 0, 12322, 12323, 7, 6, + 0, 0, 12323, 12324, 5, 95, 0, 0, 12324, 12325, 7, 7, 0, 0, 12325, 12326, + 7, 26, 0, 0, 12326, 12327, 7, 6, 0, 0, 12327, 12328, 7, 7, 0, 0, 12328, + 12329, 7, 8, 0, 0, 12329, 12330, 7, 15, 0, 0, 12330, 12331, 7, 19, 0, 0, + 12331, 12332, 7, 8, 0, 0, 12332, 12333, 7, 8, 0, 0, 12333, 12334, 7, 15, + 0, 0, 12334, 12335, 7, 12, 0, 0, 12335, 12336, 7, 22, 0, 0, 12336, 2068, + 1, 0, 0, 0, 12337, 12338, 7, 11, 0, 0, 12338, 12339, 7, 6, 0, 0, 12339, + 12340, 5, 95, 0, 0, 12340, 12341, 7, 22, 0, 0, 12341, 12342, 7, 7, 0, 0, + 12342, 12343, 7, 19, 0, 0, 12343, 12344, 7, 23, 0, 0, 12344, 12345, 7, + 14, 0, 0, 12345, 12346, 7, 19, 0, 0, 12346, 12347, 7, 5, 0, 0, 12347, 12348, + 7, 5, 0, 0, 12348, 12349, 7, 18, 0, 0, 12349, 12350, 7, 8, 0, 0, 12350, + 12351, 7, 19, 0, 0, 12351, 12352, 7, 23, 0, 0, 12352, 12353, 7, 6, 0, 0, + 12353, 12354, 7, 7, 0, 0, 12354, 12355, 7, 26, 0, 0, 12355, 12356, 7, 6, + 0, 0, 12356, 2070, 1, 0, 0, 0, 12357, 12358, 7, 11, 0, 0, 12358, 12359, + 7, 6, 0, 0, 12359, 12360, 5, 95, 0, 0, 12360, 12361, 7, 22, 0, 0, 12361, + 12362, 7, 7, 0, 0, 12362, 12363, 7, 19, 0, 0, 12363, 12364, 7, 23, 0, 0, + 12364, 12365, 7, 14, 0, 0, 12365, 12366, 7, 19, 0, 0, 12366, 12367, 7, + 5, 0, 0, 12367, 12368, 7, 5, 0, 0, 12368, 12369, 7, 18, 0, 0, 12369, 12370, + 7, 8, 0, 0, 12370, 12371, 7, 19, 0, 0, 12371, 12372, 7, 23, 0, 0, 12372, + 12373, 7, 6, 0, 0, 12373, 12374, 7, 26, 0, 0, 12374, 12375, 7, 6, 0, 0, + 12375, 2072, 1, 0, 0, 0, 12376, 12377, 7, 11, 0, 0, 12377, 12378, 7, 6, + 0, 0, 12378, 12379, 5, 95, 0, 0, 12379, 12380, 7, 22, 0, 0, 12380, 12381, + 7, 7, 0, 0, 12381, 12382, 7, 19, 0, 0, 12382, 12383, 7, 23, 0, 0, 12383, + 12384, 7, 14, 0, 0, 12384, 12385, 7, 19, 0, 0, 12385, 12386, 7, 5, 0, 0, + 12386, 12387, 7, 5, 0, 0, 12387, 12388, 7, 18, 0, 0, 12388, 12389, 7, 8, + 0, 0, 12389, 12390, 7, 19, 0, 0, 12390, 12391, 7, 23, 0, 0, 12391, 12392, + 7, 9, 0, 0, 12392, 12393, 7, 21, 0, 0, 12393, 12394, 7, 16, 0, 0, 12394, + 2074, 1, 0, 0, 0, 12395, 12396, 7, 11, 0, 0, 12396, 12397, 7, 6, 0, 0, + 12397, 12398, 5, 95, 0, 0, 12398, 12399, 7, 22, 0, 0, 12399, 12400, 7, + 7, 0, 0, 12400, 12401, 7, 19, 0, 0, 12401, 12402, 7, 23, 0, 0, 12402, 12403, + 7, 7, 0, 0, 12403, 12404, 7, 6, 0, 0, 12404, 12405, 7, 8, 0, 0, 12405, + 12406, 7, 10, 0, 0, 12406, 12407, 7, 14, 0, 0, 12407, 12408, 7, 19, 0, + 0, 12408, 12409, 7, 5, 0, 0, 12409, 12410, 7, 5, 0, 0, 12410, 12411, 7, + 7, 0, 0, 12411, 12412, 7, 14, 0, 0, 12412, 12413, 7, 6, 0, 0, 12413, 12414, + 7, 15, 0, 0, 12414, 12415, 7, 19, 0, 0, 12415, 12416, 7, 12, 0, 0, 12416, + 12417, 7, 18, 0, 0, 12417, 12418, 7, 8, 0, 0, 12418, 12419, 7, 19, 0, 0, + 12419, 12420, 7, 23, 0, 0, 12420, 12421, 7, 6, 0, 0, 12421, 12422, 7, 7, + 0, 0, 12422, 12423, 7, 26, 0, 0, 12423, 12424, 7, 6, 0, 0, 12424, 2076, + 1, 0, 0, 0, 12425, 12426, 7, 11, 0, 0, 12426, 12427, 7, 6, 0, 0, 12427, + 12428, 5, 95, 0, 0, 12428, 12429, 7, 22, 0, 0, 12429, 12430, 7, 7, 0, 0, + 12430, 12431, 7, 19, 0, 0, 12431, 12432, 7, 23, 0, 0, 12432, 12433, 7, + 7, 0, 0, 12433, 12434, 7, 6, 0, 0, 12434, 12435, 7, 8, 0, 0, 12435, 12436, + 7, 10, 0, 0, 12436, 12437, 7, 14, 0, 0, 12437, 12438, 7, 19, 0, 0, 12438, + 12439, 7, 5, 0, 0, 12439, 12440, 7, 5, 0, 0, 12440, 12441, 7, 7, 0, 0, + 12441, 12442, 7, 14, 0, 0, 12442, 12443, 7, 6, 0, 0, 12443, 12444, 7, 15, + 0, 0, 12444, 12445, 7, 19, 0, 0, 12445, 12446, 7, 12, 0, 0, 12446, 12447, + 7, 18, 0, 0, 12447, 12448, 7, 8, 0, 0, 12448, 12449, 7, 19, 0, 0, 12449, + 12450, 7, 23, 0, 0, 12450, 12451, 7, 9, 0, 0, 12451, 12452, 7, 21, 0, 0, + 12452, 12453, 7, 16, 0, 0, 12453, 2078, 1, 0, 0, 0, 12454, 12455, 7, 11, + 0, 0, 12455, 12456, 7, 6, 0, 0, 12456, 12457, 5, 95, 0, 0, 12457, 12458, + 7, 22, 0, 0, 12458, 12459, 7, 7, 0, 0, 12459, 12460, 7, 19, 0, 0, 12460, + 12461, 7, 23, 0, 0, 12461, 12462, 7, 7, 0, 0, 12462, 12463, 7, 6, 0, 0, + 12463, 12464, 7, 8, 0, 0, 12464, 12465, 7, 10, 0, 0, 12465, 12466, 7, 18, + 0, 0, 12466, 12467, 7, 8, 0, 0, 12467, 12468, 7, 19, 0, 0, 12468, 12469, + 7, 23, 0, 0, 12469, 12470, 7, 6, 0, 0, 12470, 12471, 7, 7, 0, 0, 12471, + 12472, 7, 26, 0, 0, 12472, 12473, 7, 6, 0, 0, 12473, 2080, 1, 0, 0, 0, + 12474, 12475, 7, 11, 0, 0, 12475, 12476, 7, 6, 0, 0, 12476, 12477, 5, 95, + 0, 0, 12477, 12478, 7, 22, 0, 0, 12478, 12479, 7, 7, 0, 0, 12479, 12480, + 7, 19, 0, 0, 12480, 12481, 7, 23, 0, 0, 12481, 12482, 7, 7, 0, 0, 12482, + 12483, 7, 6, 0, 0, 12483, 12484, 7, 8, 0, 0, 12484, 12485, 7, 10, 0, 0, + 12485, 12486, 7, 18, 0, 0, 12486, 12487, 7, 8, 0, 0, 12487, 12488, 7, 19, + 0, 0, 12488, 12489, 7, 23, 0, 0, 12489, 12490, 7, 9, 0, 0, 12490, 12491, + 7, 21, 0, 0, 12491, 12492, 7, 16, 0, 0, 12492, 2082, 1, 0, 0, 0, 12493, + 12494, 7, 11, 0, 0, 12494, 12495, 7, 6, 0, 0, 12495, 12496, 5, 95, 0, 0, + 12496, 12497, 7, 22, 0, 0, 12497, 12498, 7, 7, 0, 0, 12498, 12499, 7, 19, + 0, 0, 12499, 12500, 7, 23, 0, 0, 12500, 12501, 7, 7, 0, 0, 12501, 12502, + 7, 6, 0, 0, 12502, 12503, 7, 8, 0, 0, 12503, 12504, 7, 10, 0, 0, 12504, + 12505, 7, 12, 0, 0, 12505, 2084, 1, 0, 0, 0, 12506, 12507, 7, 11, 0, 0, + 12507, 12508, 7, 6, 0, 0, 12508, 12509, 5, 95, 0, 0, 12509, 12510, 7, 22, + 0, 0, 12510, 12511, 7, 7, 0, 0, 12511, 12512, 7, 19, 0, 0, 12512, 12513, + 7, 23, 0, 0, 12513, 12514, 7, 7, 0, 0, 12514, 12515, 7, 6, 0, 0, 12515, + 12516, 7, 8, 0, 0, 12516, 12517, 7, 10, 0, 0, 12517, 12518, 7, 6, 0, 0, + 12518, 12519, 7, 10, 0, 0, 12519, 12520, 7, 25, 0, 0, 12520, 12521, 7, + 7, 0, 0, 12521, 2086, 1, 0, 0, 0, 12522, 12523, 7, 11, 0, 0, 12523, 12524, + 7, 6, 0, 0, 12524, 12525, 5, 95, 0, 0, 12525, 12526, 7, 22, 0, 0, 12526, + 12527, 7, 7, 0, 0, 12527, 12528, 7, 19, 0, 0, 12528, 12529, 7, 23, 0, 0, + 12529, 12530, 7, 18, 0, 0, 12530, 12531, 7, 8, 0, 0, 12531, 12532, 7, 19, + 0, 0, 12532, 12533, 7, 23, 0, 0, 12533, 12534, 7, 6, 0, 0, 12534, 12535, + 7, 7, 0, 0, 12535, 12536, 7, 26, 0, 0, 12536, 12537, 7, 6, 0, 0, 12537, + 2088, 1, 0, 0, 0, 12538, 12539, 7, 11, 0, 0, 12539, 12540, 7, 6, 0, 0, + 12540, 12541, 5, 95, 0, 0, 12541, 12542, 7, 22, 0, 0, 12542, 12543, 7, + 7, 0, 0, 12543, 12544, 7, 19, 0, 0, 12544, 12545, 7, 23, 0, 0, 12545, 12546, + 7, 18, 0, 0, 12546, 12547, 7, 8, 0, 0, 12547, 12548, 7, 19, 0, 0, 12548, + 12549, 7, 23, 0, 0, 12549, 12550, 7, 9, 0, 0, 12550, 12551, 7, 21, 0, 0, + 12551, 12552, 7, 16, 0, 0, 12552, 2090, 1, 0, 0, 0, 12553, 12554, 7, 11, + 0, 0, 12554, 12555, 7, 6, 0, 0, 12555, 12556, 5, 95, 0, 0, 12556, 12557, + 7, 15, 0, 0, 12557, 12558, 7, 12, 0, 0, 12558, 12559, 7, 6, 0, 0, 12559, + 12560, 7, 7, 0, 0, 12560, 12561, 7, 8, 0, 0, 12561, 12562, 7, 15, 0, 0, + 12562, 12563, 7, 19, 0, 0, 12563, 12564, 7, 8, 0, 0, 12564, 12565, 7, 8, + 0, 0, 12565, 12566, 7, 15, 0, 0, 12566, 12567, 7, 12, 0, 0, 12567, 12568, + 7, 22, 0, 0, 12568, 12569, 7, 12, 0, 0, 12569, 2092, 1, 0, 0, 0, 12570, + 12571, 7, 11, 0, 0, 12571, 12572, 7, 6, 0, 0, 12572, 12573, 5, 95, 0, 0, + 12573, 12574, 7, 15, 0, 0, 12574, 12575, 7, 12, 0, 0, 12575, 12576, 7, + 6, 0, 0, 12576, 12577, 7, 7, 0, 0, 12577, 12578, 7, 8, 0, 0, 12578, 12579, + 7, 11, 0, 0, 12579, 12580, 7, 7, 0, 0, 12580, 12581, 7, 14, 0, 0, 12581, + 12582, 7, 6, 0, 0, 12582, 12583, 7, 15, 0, 0, 12583, 12584, 7, 19, 0, 0, + 12584, 12585, 7, 12, 0, 0, 12585, 2094, 1, 0, 0, 0, 12586, 12587, 7, 11, + 0, 0, 12587, 12588, 7, 6, 0, 0, 12588, 12589, 5, 95, 0, 0, 12589, 12590, + 7, 15, 0, 0, 12590, 12591, 7, 12, 0, 0, 12591, 12592, 7, 6, 0, 0, 12592, + 12593, 7, 7, 0, 0, 12593, 12594, 7, 8, 0, 0, 12594, 12595, 7, 11, 0, 0, + 12595, 12596, 7, 7, 0, 0, 12596, 12597, 7, 14, 0, 0, 12597, 12598, 7, 6, + 0, 0, 12598, 12599, 7, 11, 0, 0, 12599, 2096, 1, 0, 0, 0, 12600, 12601, + 7, 11, 0, 0, 12601, 12602, 7, 6, 0, 0, 12602, 12603, 5, 95, 0, 0, 12603, + 12604, 7, 15, 0, 0, 12604, 12605, 7, 11, 0, 0, 12605, 12606, 7, 14, 0, + 0, 12606, 12607, 7, 5, 0, 0, 12607, 12608, 7, 19, 0, 0, 12608, 12609, 7, + 11, 0, 0, 12609, 12610, 7, 7, 0, 0, 12610, 12611, 7, 4, 0, 0, 12611, 2098, + 1, 0, 0, 0, 12612, 12613, 7, 11, 0, 0, 12613, 12614, 7, 6, 0, 0, 12614, + 12615, 5, 95, 0, 0, 12615, 12616, 7, 15, 0, 0, 12616, 12617, 7, 11, 0, + 0, 12617, 12618, 7, 7, 0, 0, 12618, 12619, 7, 23, 0, 0, 12619, 12620, 7, + 25, 0, 0, 12620, 12621, 7, 6, 0, 0, 12621, 12622, 7, 10, 0, 0, 12622, 2100, + 1, 0, 0, 0, 12623, 12624, 7, 11, 0, 0, 12624, 12625, 7, 6, 0, 0, 12625, + 12626, 5, 95, 0, 0, 12626, 12627, 7, 15, 0, 0, 12627, 12628, 7, 11, 0, + 0, 12628, 12629, 7, 11, 0, 0, 12629, 12630, 7, 15, 0, 0, 12630, 12631, + 7, 23, 0, 0, 12631, 12632, 7, 25, 0, 0, 12632, 12633, 7, 5, 0, 0, 12633, + 12634, 7, 7, 0, 0, 12634, 2102, 1, 0, 0, 0, 12635, 12636, 7, 11, 0, 0, + 12636, 12637, 7, 6, 0, 0, 12637, 12638, 5, 95, 0, 0, 12638, 12639, 7, 5, + 0, 0, 12639, 12640, 7, 15, 0, 0, 12640, 12641, 7, 12, 0, 0, 12641, 12642, + 7, 7, 0, 0, 12642, 12643, 7, 18, 0, 0, 12643, 12644, 7, 8, 0, 0, 12644, + 12645, 7, 19, 0, 0, 12645, 12646, 7, 23, 0, 0, 12646, 12647, 7, 6, 0, 0, + 12647, 12648, 7, 7, 0, 0, 12648, 12649, 7, 26, 0, 0, 12649, 12650, 7, 6, + 0, 0, 12650, 2104, 1, 0, 0, 0, 12651, 12652, 7, 11, 0, 0, 12652, 12653, + 7, 6, 0, 0, 12653, 12654, 5, 95, 0, 0, 12654, 12655, 7, 5, 0, 0, 12655, + 12656, 7, 15, 0, 0, 12656, 12657, 7, 12, 0, 0, 12657, 12658, 7, 7, 0, 0, + 12658, 12659, 7, 18, 0, 0, 12659, 12660, 7, 8, 0, 0, 12660, 12661, 7, 19, + 0, 0, 12661, 12662, 7, 23, 0, 0, 12662, 12663, 7, 9, 0, 0, 12663, 12664, + 7, 21, 0, 0, 12664, 12665, 7, 16, 0, 0, 12665, 2106, 1, 0, 0, 0, 12666, + 12667, 7, 11, 0, 0, 12667, 12668, 7, 6, 0, 0, 12668, 12669, 5, 95, 0, 0, + 12669, 12670, 7, 5, 0, 0, 12670, 12671, 7, 15, 0, 0, 12671, 12672, 7, 12, + 0, 0, 12672, 12673, 7, 7, 0, 0, 12673, 12674, 7, 11, 0, 0, 12674, 12675, + 7, 6, 0, 0, 12675, 12676, 7, 8, 0, 0, 12676, 12677, 7, 15, 0, 0, 12677, + 12678, 7, 12, 0, 0, 12678, 12679, 7, 22, 0, 0, 12679, 12680, 7, 18, 0, + 0, 12680, 12681, 7, 8, 0, 0, 12681, 12682, 7, 19, 0, 0, 12682, 12683, 7, + 23, 0, 0, 12683, 12684, 7, 6, 0, 0, 12684, 12685, 7, 7, 0, 0, 12685, 12686, + 7, 26, 0, 0, 12686, 12687, 7, 6, 0, 0, 12687, 2108, 1, 0, 0, 0, 12688, + 12689, 7, 11, 0, 0, 12689, 12690, 7, 6, 0, 0, 12690, 12691, 5, 95, 0, 0, + 12691, 12692, 7, 5, 0, 0, 12692, 12693, 7, 15, 0, 0, 12693, 12694, 7, 12, + 0, 0, 12694, 12695, 7, 7, 0, 0, 12695, 12696, 7, 11, 0, 0, 12696, 12697, + 7, 6, 0, 0, 12697, 12698, 7, 8, 0, 0, 12698, 12699, 7, 15, 0, 0, 12699, + 12700, 7, 12, 0, 0, 12700, 12701, 7, 22, 0, 0, 12701, 12702, 7, 18, 0, + 0, 12702, 12703, 7, 8, 0, 0, 12703, 12704, 7, 19, 0, 0, 12704, 12705, 7, + 23, 0, 0, 12705, 12706, 7, 9, 0, 0, 12706, 12707, 7, 21, 0, 0, 12707, 12708, + 7, 16, 0, 0, 12708, 2110, 1, 0, 0, 0, 12709, 12710, 7, 11, 0, 0, 12710, + 12711, 7, 6, 0, 0, 12711, 12712, 5, 95, 0, 0, 12712, 12713, 7, 12, 0, 0, + 12713, 12714, 7, 17, 0, 0, 12714, 12715, 7, 23, 0, 0, 12715, 12716, 7, + 22, 0, 0, 12716, 12717, 7, 7, 0, 0, 12717, 12718, 7, 19, 0, 0, 12718, 12719, + 7, 23, 0, 0, 12719, 12720, 7, 7, 0, 0, 12720, 12721, 7, 6, 0, 0, 12721, + 12722, 7, 8, 0, 0, 12722, 12723, 7, 15, 0, 0, 12723, 12724, 7, 7, 0, 0, + 12724, 12725, 7, 11, 0, 0, 12725, 2112, 1, 0, 0, 0, 12726, 12727, 7, 11, + 0, 0, 12727, 12728, 7, 6, 0, 0, 12728, 12729, 5, 95, 0, 0, 12729, 12730, + 7, 12, 0, 0, 12730, 12731, 7, 17, 0, 0, 12731, 12732, 7, 23, 0, 0, 12732, + 12733, 7, 15, 0, 0, 12733, 12734, 7, 12, 0, 0, 12734, 12735, 7, 6, 0, 0, + 12735, 12736, 7, 7, 0, 0, 12736, 12737, 7, 8, 0, 0, 12737, 12738, 7, 15, + 0, 0, 12738, 12739, 7, 19, 0, 0, 12739, 12740, 7, 8, 0, 0, 12740, 12741, + 7, 8, 0, 0, 12741, 12742, 7, 15, 0, 0, 12742, 12743, 7, 12, 0, 0, 12743, + 12744, 7, 22, 0, 0, 12744, 2114, 1, 0, 0, 0, 12745, 12746, 7, 11, 0, 0, + 12746, 12747, 7, 6, 0, 0, 12747, 12748, 5, 95, 0, 0, 12748, 12749, 7, 12, + 0, 0, 12749, 12750, 7, 17, 0, 0, 12750, 12751, 7, 23, 0, 0, 12751, 12752, + 7, 15, 0, 0, 12752, 12753, 7, 12, 0, 0, 12753, 12754, 7, 6, 0, 0, 12754, + 12755, 7, 7, 0, 0, 12755, 12756, 7, 8, 0, 0, 12756, 12757, 7, 15, 0, 0, + 12757, 12758, 7, 19, 0, 0, 12758, 12759, 7, 8, 0, 0, 12759, 12760, 7, 8, + 0, 0, 12760, 12761, 7, 15, 0, 0, 12761, 12762, 7, 12, 0, 0, 12762, 12763, + 7, 22, 0, 0, 12763, 12764, 7, 11, 0, 0, 12764, 2116, 1, 0, 0, 0, 12765, + 12766, 7, 11, 0, 0, 12766, 12767, 7, 6, 0, 0, 12767, 12768, 5, 95, 0, 0, + 12768, 12769, 7, 12, 0, 0, 12769, 12770, 7, 17, 0, 0, 12770, 12771, 7, + 23, 0, 0, 12771, 12772, 7, 25, 0, 0, 12772, 12773, 7, 19, 0, 0, 12773, + 12774, 7, 15, 0, 0, 12774, 12775, 7, 12, 0, 0, 12775, 12776, 7, 6, 0, 0, + 12776, 12777, 7, 11, 0, 0, 12777, 2118, 1, 0, 0, 0, 12778, 12779, 7, 11, + 0, 0, 12779, 12780, 7, 6, 0, 0, 12780, 12781, 5, 95, 0, 0, 12781, 12782, + 7, 19, 0, 0, 12782, 12783, 7, 24, 0, 0, 12783, 12784, 7, 7, 0, 0, 12784, + 12785, 7, 8, 0, 0, 12785, 12786, 7, 5, 0, 0, 12786, 12787, 7, 3, 0, 0, + 12787, 12788, 7, 25, 0, 0, 12788, 12789, 7, 11, 0, 0, 12789, 2120, 1, 0, + 0, 0, 12790, 12791, 7, 11, 0, 0, 12791, 12792, 7, 6, 0, 0, 12792, 12793, + 5, 95, 0, 0, 12793, 12794, 7, 25, 0, 0, 12794, 12795, 7, 19, 0, 0, 12795, + 12796, 7, 15, 0, 0, 12796, 12797, 7, 12, 0, 0, 12797, 12798, 7, 6, 0, 0, + 12798, 12799, 7, 18, 0, 0, 12799, 12800, 7, 8, 0, 0, 12800, 12801, 7, 19, + 0, 0, 12801, 12802, 7, 23, 0, 0, 12802, 12803, 7, 6, 0, 0, 12803, 12804, + 7, 7, 0, 0, 12804, 12805, 7, 26, 0, 0, 12805, 12806, 7, 6, 0, 0, 12806, + 2122, 1, 0, 0, 0, 12807, 12808, 7, 11, 0, 0, 12808, 12809, 7, 6, 0, 0, + 12809, 12810, 5, 95, 0, 0, 12810, 12811, 7, 25, 0, 0, 12811, 12812, 7, + 19, 0, 0, 12812, 12813, 7, 15, 0, 0, 12813, 12814, 7, 12, 0, 0, 12814, + 12815, 7, 6, 0, 0, 12815, 12816, 7, 18, 0, 0, 12816, 12817, 7, 8, 0, 0, + 12817, 12818, 7, 19, 0, 0, 12818, 12819, 7, 23, 0, 0, 12819, 12820, 7, + 9, 0, 0, 12820, 12821, 7, 21, 0, 0, 12821, 12822, 7, 16, 0, 0, 12822, 2124, + 1, 0, 0, 0, 12823, 12824, 7, 11, 0, 0, 12824, 12825, 7, 6, 0, 0, 12825, + 12826, 5, 95, 0, 0, 12826, 12827, 7, 25, 0, 0, 12827, 12828, 7, 19, 0, + 0, 12828, 12829, 7, 15, 0, 0, 12829, 12830, 7, 12, 0, 0, 12830, 12831, + 7, 6, 0, 0, 12831, 12832, 7, 12, 0, 0, 12832, 2126, 1, 0, 0, 0, 12833, + 12834, 7, 11, 0, 0, 12834, 12835, 7, 6, 0, 0, 12835, 12836, 5, 95, 0, 0, + 12836, 12837, 7, 25, 0, 0, 12837, 12838, 7, 19, 0, 0, 12838, 12839, 7, + 5, 0, 0, 12839, 12840, 7, 10, 0, 0, 12840, 12841, 7, 18, 0, 0, 12841, 12842, + 7, 8, 0, 0, 12842, 12843, 7, 19, 0, 0, 12843, 12844, 7, 23, 0, 0, 12844, + 12845, 7, 6, 0, 0, 12845, 12846, 7, 7, 0, 0, 12846, 12847, 7, 26, 0, 0, + 12847, 12848, 7, 6, 0, 0, 12848, 2128, 1, 0, 0, 0, 12849, 12850, 7, 11, + 0, 0, 12850, 12851, 7, 6, 0, 0, 12851, 12852, 5, 95, 0, 0, 12852, 12853, + 7, 25, 0, 0, 12853, 12854, 7, 19, 0, 0, 12854, 12855, 7, 5, 0, 0, 12855, + 12856, 7, 10, 0, 0, 12856, 12857, 7, 18, 0, 0, 12857, 12858, 7, 8, 0, 0, + 12858, 12859, 7, 19, 0, 0, 12859, 12860, 7, 23, 0, 0, 12860, 12861, 7, + 9, 0, 0, 12861, 12862, 7, 21, 0, 0, 12862, 12863, 7, 16, 0, 0, 12863, 2130, + 1, 0, 0, 0, 12864, 12865, 7, 11, 0, 0, 12865, 12866, 7, 6, 0, 0, 12866, + 12867, 5, 95, 0, 0, 12867, 12868, 7, 25, 0, 0, 12868, 12869, 7, 19, 0, + 0, 12869, 12870, 7, 5, 0, 0, 12870, 12871, 7, 10, 0, 0, 12871, 12872, 7, + 22, 0, 0, 12872, 12873, 7, 19, 0, 0, 12873, 12874, 7, 12, 0, 0, 12874, + 12875, 7, 18, 0, 0, 12875, 12876, 7, 8, 0, 0, 12876, 12877, 7, 19, 0, 0, + 12877, 12878, 7, 23, 0, 0, 12878, 12879, 7, 6, 0, 0, 12879, 12880, 7, 7, + 0, 0, 12880, 12881, 7, 26, 0, 0, 12881, 12882, 7, 6, 0, 0, 12882, 2132, + 1, 0, 0, 0, 12883, 12884, 7, 11, 0, 0, 12884, 12885, 7, 6, 0, 0, 12885, + 12886, 5, 95, 0, 0, 12886, 12887, 7, 25, 0, 0, 12887, 12888, 7, 19, 0, + 0, 12888, 12889, 7, 5, 0, 0, 12889, 12890, 7, 10, 0, 0, 12890, 12891, 7, + 22, 0, 0, 12891, 12892, 7, 19, 0, 0, 12892, 12893, 7, 12, 0, 0, 12893, + 12894, 7, 18, 0, 0, 12894, 12895, 7, 8, 0, 0, 12895, 12896, 7, 19, 0, 0, + 12896, 12897, 7, 23, 0, 0, 12897, 12898, 7, 9, 0, 0, 12898, 12899, 7, 21, + 0, 0, 12899, 12900, 7, 16, 0, 0, 12900, 2134, 1, 0, 0, 0, 12901, 12902, + 7, 11, 0, 0, 12902, 12903, 7, 6, 0, 0, 12903, 12904, 5, 95, 0, 0, 12904, + 12905, 7, 11, 0, 0, 12905, 12906, 7, 8, 0, 0, 12906, 12907, 7, 15, 0, 0, + 12907, 12908, 7, 4, 0, 0, 12908, 2136, 1, 0, 0, 0, 12909, 12910, 7, 11, + 0, 0, 12910, 12911, 7, 6, 0, 0, 12911, 12912, 5, 95, 0, 0, 12912, 12913, + 7, 11, 0, 0, 12913, 12914, 7, 6, 0, 0, 12914, 12915, 7, 3, 0, 0, 12915, + 12916, 7, 8, 0, 0, 12916, 12917, 7, 6, 0, 0, 12917, 12918, 7, 25, 0, 0, + 12918, 12919, 7, 19, 0, 0, 12919, 12920, 7, 15, 0, 0, 12920, 12921, 7, + 12, 0, 0, 12921, 12922, 7, 6, 0, 0, 12922, 2138, 1, 0, 0, 0, 12923, 12924, + 7, 11, 0, 0, 12924, 12925, 7, 6, 0, 0, 12925, 12926, 5, 95, 0, 0, 12926, + 12927, 7, 11, 0, 0, 12927, 12928, 7, 10, 0, 0, 12928, 12929, 7, 23, 0, + 0, 12929, 12930, 7, 4, 0, 0, 12930, 12931, 7, 15, 0, 0, 12931, 12932, 7, + 18, 0, 0, 12932, 12933, 7, 18, 0, 0, 12933, 12934, 7, 7, 0, 0, 12934, 12935, + 7, 8, 0, 0, 12935, 12936, 7, 7, 0, 0, 12936, 12937, 7, 12, 0, 0, 12937, + 12938, 7, 14, 0, 0, 12938, 12939, 7, 7, 0, 0, 12939, 2140, 1, 0, 0, 0, + 12940, 12941, 7, 11, 0, 0, 12941, 12942, 7, 6, 0, 0, 12942, 12943, 5, 95, + 0, 0, 12943, 12944, 7, 6, 0, 0, 12944, 12945, 7, 19, 0, 0, 12945, 12946, + 7, 17, 0, 0, 12946, 12947, 7, 14, 0, 0, 12947, 12948, 7, 20, 0, 0, 12948, + 12949, 7, 7, 0, 0, 12949, 12950, 7, 11, 0, 0, 12950, 2142, 1, 0, 0, 0, + 12951, 12952, 7, 11, 0, 0, 12952, 12953, 7, 6, 0, 0, 12953, 12954, 5, 95, + 0, 0, 12954, 12955, 7, 17, 0, 0, 12955, 12956, 7, 12, 0, 0, 12956, 12957, + 7, 15, 0, 0, 12957, 12958, 7, 19, 0, 0, 12958, 12959, 7, 12, 0, 0, 12959, + 2144, 1, 0, 0, 0, 12960, 12961, 7, 11, 0, 0, 12961, 12962, 7, 6, 0, 0, + 12962, 12963, 5, 95, 0, 0, 12963, 12964, 7, 9, 0, 0, 12964, 12965, 7, 15, + 0, 0, 12965, 12966, 7, 6, 0, 0, 12966, 12967, 7, 20, 0, 0, 12967, 12968, + 7, 15, 0, 0, 12968, 12969, 7, 12, 0, 0, 12969, 2146, 1, 0, 0, 0, 12970, + 12971, 7, 11, 0, 0, 12971, 12972, 7, 6, 0, 0, 12972, 12973, 5, 95, 0, 0, + 12973, 12974, 7, 26, 0, 0, 12974, 2148, 1, 0, 0, 0, 12975, 12976, 7, 11, + 0, 0, 12976, 12977, 7, 6, 0, 0, 12977, 12978, 5, 95, 0, 0, 12978, 12979, + 7, 10, 0, 0, 12979, 2150, 1, 0, 0, 0, 12980, 12981, 7, 11, 0, 0, 12981, + 12982, 7, 6, 0, 0, 12982, 12983, 7, 8, 0, 0, 12983, 12984, 7, 15, 0, 0, + 12984, 12985, 7, 12, 0, 0, 12985, 12986, 7, 22, 0, 0, 12986, 12987, 5, + 95, 0, 0, 12987, 12988, 7, 6, 0, 0, 12988, 12989, 7, 19, 0, 0, 12989, 12990, + 5, 95, 0, 0, 12990, 12991, 7, 24, 0, 0, 12991, 12992, 7, 7, 0, 0, 12992, + 12993, 7, 14, 0, 0, 12993, 12994, 7, 6, 0, 0, 12994, 12995, 7, 19, 0, 0, + 12995, 12996, 7, 8, 0, 0, 12996, 2152, 1, 0, 0, 0, 12997, 12998, 7, 11, + 0, 0, 12998, 12999, 7, 17, 0, 0, 12999, 13000, 7, 16, 0, 0, 13000, 13001, + 7, 4, 0, 0, 13001, 13002, 7, 3, 0, 0, 13002, 13003, 7, 6, 0, 0, 13003, + 13004, 7, 7, 0, 0, 13004, 2154, 1, 0, 0, 0, 13005, 13006, 7, 11, 0, 0, + 13006, 13007, 7, 17, 0, 0, 13007, 13008, 7, 16, 0, 0, 13008, 13009, 7, + 11, 0, 0, 13009, 13010, 7, 6, 0, 0, 13010, 13011, 7, 8, 0, 0, 13011, 13012, + 7, 15, 0, 0, 13012, 13013, 7, 12, 0, 0, 13013, 13014, 7, 22, 0, 0, 13014, + 13015, 5, 95, 0, 0, 13015, 13016, 7, 15, 0, 0, 13016, 13017, 7, 12, 0, + 0, 13017, 13018, 7, 4, 0, 0, 13018, 13019, 7, 7, 0, 0, 13019, 13020, 7, + 26, 0, 0, 13020, 2156, 1, 0, 0, 0, 13021, 13022, 7, 11, 0, 0, 13022, 13023, + 7, 17, 0, 0, 13023, 13024, 7, 16, 0, 0, 13024, 13025, 7, 6, 0, 0, 13025, + 13026, 7, 15, 0, 0, 13026, 13027, 7, 23, 0, 0, 13027, 13028, 7, 7, 0, 0, + 13028, 2158, 1, 0, 0, 0, 13029, 13030, 7, 11, 0, 0, 13030, 13031, 7, 10, + 0, 0, 13031, 13032, 7, 11, 0, 0, 13032, 13033, 7, 6, 0, 0, 13033, 13034, + 7, 7, 0, 0, 13034, 13035, 7, 23, 0, 0, 13035, 13036, 5, 95, 0, 0, 13036, + 13037, 7, 17, 0, 0, 13037, 13038, 7, 11, 0, 0, 13038, 13039, 7, 7, 0, 0, + 13039, 13040, 7, 8, 0, 0, 13040, 2160, 1, 0, 0, 0, 13041, 13042, 7, 6, + 0, 0, 13042, 13043, 7, 3, 0, 0, 13043, 13044, 7, 12, 0, 0, 13044, 2162, + 1, 0, 0, 0, 13045, 13046, 7, 6, 0, 0, 13046, 13047, 7, 15, 0, 0, 13047, + 13048, 7, 23, 0, 0, 13048, 13049, 7, 7, 0, 0, 13049, 13050, 7, 4, 0, 0, + 13050, 13051, 7, 15, 0, 0, 13051, 13052, 7, 18, 0, 0, 13052, 13053, 7, + 18, 0, 0, 13053, 2164, 1, 0, 0, 0, 13054, 13055, 7, 6, 0, 0, 13055, 13056, + 7, 15, 0, 0, 13056, 13057, 7, 23, 0, 0, 13057, 13058, 7, 7, 0, 0, 13058, + 13059, 7, 11, 0, 0, 13059, 13060, 7, 6, 0, 0, 13060, 13061, 7, 3, 0, 0, + 13061, 13062, 7, 23, 0, 0, 13062, 13063, 7, 25, 0, 0, 13063, 13064, 7, + 3, 0, 0, 13064, 13065, 7, 4, 0, 0, 13065, 13066, 7, 4, 0, 0, 13066, 2166, + 1, 0, 0, 0, 13067, 13068, 7, 6, 0, 0, 13068, 13069, 7, 15, 0, 0, 13069, + 13070, 7, 23, 0, 0, 13070, 13071, 7, 7, 0, 0, 13071, 13072, 7, 11, 0, 0, + 13072, 13073, 7, 6, 0, 0, 13073, 13074, 7, 3, 0, 0, 13074, 13075, 7, 23, + 0, 0, 13075, 13076, 7, 25, 0, 0, 13076, 13077, 7, 4, 0, 0, 13077, 13078, + 7, 15, 0, 0, 13078, 13079, 7, 18, 0, 0, 13079, 13080, 7, 18, 0, 0, 13080, + 2168, 1, 0, 0, 0, 13081, 13082, 7, 6, 0, 0, 13082, 13083, 7, 15, 0, 0, + 13083, 13084, 7, 23, 0, 0, 13084, 13085, 7, 7, 0, 0, 13085, 13086, 5, 95, + 0, 0, 13086, 13087, 7, 18, 0, 0, 13087, 13088, 7, 19, 0, 0, 13088, 13089, + 7, 8, 0, 0, 13089, 13090, 7, 23, 0, 0, 13090, 13091, 7, 3, 0, 0, 13091, + 13092, 7, 6, 0, 0, 13092, 2170, 1, 0, 0, 0, 13093, 13094, 7, 6, 0, 0, 13094, + 13095, 7, 15, 0, 0, 13095, 13096, 7, 23, 0, 0, 13096, 13097, 7, 7, 0, 0, + 13097, 13098, 5, 95, 0, 0, 13098, 13099, 7, 6, 0, 0, 13099, 13100, 7, 19, + 0, 0, 13100, 13101, 5, 95, 0, 0, 13101, 13102, 7, 11, 0, 0, 13102, 13103, + 7, 7, 0, 0, 13103, 13104, 7, 14, 0, 0, 13104, 2172, 1, 0, 0, 0, 13105, + 13106, 7, 6, 0, 0, 13106, 13107, 7, 19, 0, 0, 13107, 13108, 7, 17, 0, 0, + 13108, 13109, 7, 14, 0, 0, 13109, 13110, 7, 20, 0, 0, 13110, 13111, 7, + 7, 0, 0, 13111, 13112, 7, 11, 0, 0, 13112, 2174, 1, 0, 0, 0, 13113, 13114, + 7, 6, 0, 0, 13114, 13115, 7, 19, 0, 0, 13115, 13116, 5, 95, 0, 0, 13116, + 13117, 7, 16, 0, 0, 13117, 13118, 7, 3, 0, 0, 13118, 13119, 7, 11, 0, 0, + 13119, 13120, 7, 7, 0, 0, 13120, 13121, 5, 54, 0, 0, 13121, 13122, 5, 52, + 0, 0, 13122, 2176, 1, 0, 0, 0, 13123, 13124, 7, 6, 0, 0, 13124, 13125, + 7, 19, 0, 0, 13125, 13126, 5, 95, 0, 0, 13126, 13127, 7, 4, 0, 0, 13127, + 13128, 7, 3, 0, 0, 13128, 13129, 7, 10, 0, 0, 13129, 13130, 7, 11, 0, 0, + 13130, 2178, 1, 0, 0, 0, 13131, 13132, 7, 6, 0, 0, 13132, 13133, 7, 19, + 0, 0, 13133, 13134, 5, 95, 0, 0, 13134, 13135, 7, 11, 0, 0, 13135, 13136, + 7, 7, 0, 0, 13136, 13137, 7, 14, 0, 0, 13137, 13138, 7, 19, 0, 0, 13138, + 13139, 7, 12, 0, 0, 13139, 13140, 7, 4, 0, 0, 13140, 13141, 7, 11, 0, 0, + 13141, 2180, 1, 0, 0, 0, 13142, 13143, 7, 6, 0, 0, 13143, 13144, 7, 25, + 0, 0, 13144, 13145, 5, 95, 0, 0, 13145, 13146, 7, 14, 0, 0, 13146, 13147, + 7, 19, 0, 0, 13147, 13148, 7, 12, 0, 0, 13148, 13149, 7, 12, 0, 0, 13149, + 13150, 7, 7, 0, 0, 13150, 13151, 7, 14, 0, 0, 13151, 13152, 7, 6, 0, 0, + 13152, 13153, 7, 15, 0, 0, 13153, 13154, 7, 19, 0, 0, 13154, 13155, 7, + 12, 0, 0, 13155, 13156, 5, 95, 0, 0, 13156, 13157, 7, 3, 0, 0, 13157, 13158, + 7, 4, 0, 0, 13158, 13159, 7, 23, 0, 0, 13159, 13160, 7, 15, 0, 0, 13160, + 13161, 7, 12, 0, 0, 13161, 2182, 1, 0, 0, 0, 13162, 13163, 7, 17, 0, 0, + 13163, 13164, 7, 14, 0, 0, 13164, 13165, 7, 3, 0, 0, 13165, 13166, 7, 11, + 0, 0, 13166, 13167, 7, 7, 0, 0, 13167, 2184, 1, 0, 0, 0, 13168, 13169, + 7, 17, 0, 0, 13169, 13170, 7, 12, 0, 0, 13170, 13171, 7, 14, 0, 0, 13171, + 13172, 7, 19, 0, 0, 13172, 13173, 7, 23, 0, 0, 13173, 13174, 7, 25, 0, + 0, 13174, 13175, 7, 8, 0, 0, 13175, 13176, 7, 7, 0, 0, 13176, 13177, 7, + 11, 0, 0, 13177, 13178, 7, 11, 0, 0, 13178, 2186, 1, 0, 0, 0, 13179, 13180, + 7, 17, 0, 0, 13180, 13181, 7, 12, 0, 0, 13181, 13182, 7, 14, 0, 0, 13182, + 13183, 7, 19, 0, 0, 13183, 13184, 7, 23, 0, 0, 13184, 13185, 7, 25, 0, + 0, 13185, 13186, 7, 8, 0, 0, 13186, 13187, 7, 7, 0, 0, 13187, 13188, 7, + 11, 0, 0, 13188, 13189, 7, 11, 0, 0, 13189, 13190, 7, 7, 0, 0, 13190, 13191, + 7, 4, 0, 0, 13191, 13192, 5, 95, 0, 0, 13192, 13193, 7, 5, 0, 0, 13193, + 13194, 7, 7, 0, 0, 13194, 13195, 7, 12, 0, 0, 13195, 13196, 7, 22, 0, 0, + 13196, 13197, 7, 6, 0, 0, 13197, 13198, 7, 20, 0, 0, 13198, 2188, 1, 0, + 0, 0, 13199, 13200, 7, 17, 0, 0, 13200, 13201, 7, 12, 0, 0, 13201, 13202, + 7, 20, 0, 0, 13202, 13203, 7, 7, 0, 0, 13203, 13204, 7, 26, 0, 0, 13204, + 2190, 1, 0, 0, 0, 13205, 13206, 7, 17, 0, 0, 13206, 13207, 7, 12, 0, 0, + 13207, 13208, 7, 15, 0, 0, 13208, 13209, 7, 26, 0, 0, 13209, 13210, 5, + 95, 0, 0, 13210, 13211, 7, 6, 0, 0, 13211, 13212, 7, 15, 0, 0, 13212, 13213, + 7, 23, 0, 0, 13213, 13214, 7, 7, 0, 0, 13214, 13215, 7, 11, 0, 0, 13215, + 13216, 7, 6, 0, 0, 13216, 13217, 7, 3, 0, 0, 13217, 13218, 7, 23, 0, 0, + 13218, 13219, 7, 25, 0, 0, 13219, 2192, 1, 0, 0, 0, 13220, 13221, 7, 17, + 0, 0, 13221, 13222, 7, 25, 0, 0, 13222, 13223, 7, 4, 0, 0, 13223, 13224, + 7, 3, 0, 0, 13224, 13225, 7, 6, 0, 0, 13225, 13226, 7, 7, 0, 0, 13226, + 13227, 7, 26, 0, 0, 13227, 13228, 7, 23, 0, 0, 13228, 13229, 7, 5, 0, 0, + 13229, 2194, 1, 0, 0, 0, 13230, 13231, 7, 17, 0, 0, 13231, 13232, 7, 25, + 0, 0, 13232, 13233, 7, 25, 0, 0, 13233, 13234, 7, 7, 0, 0, 13234, 13235, + 7, 8, 0, 0, 13235, 2196, 1, 0, 0, 0, 13236, 13237, 7, 17, 0, 0, 13237, + 13238, 7, 17, 0, 0, 13238, 13239, 7, 15, 0, 0, 13239, 13240, 7, 4, 0, 0, + 13240, 2198, 1, 0, 0, 0, 13241, 13242, 7, 17, 0, 0, 13242, 13243, 7, 17, + 0, 0, 13243, 13244, 7, 15, 0, 0, 13244, 13245, 7, 4, 0, 0, 13245, 13246, + 5, 95, 0, 0, 13246, 13247, 7, 11, 0, 0, 13247, 13248, 7, 20, 0, 0, 13248, + 13249, 7, 19, 0, 0, 13249, 13250, 7, 8, 0, 0, 13250, 13251, 7, 6, 0, 0, + 13251, 2200, 1, 0, 0, 0, 13252, 13253, 7, 24, 0, 0, 13253, 13254, 7, 3, + 0, 0, 13254, 13255, 7, 5, 0, 0, 13255, 13256, 7, 15, 0, 0, 13256, 13257, + 7, 4, 0, 0, 13257, 13258, 7, 3, 0, 0, 13258, 13259, 7, 6, 0, 0, 13259, + 13260, 7, 7, 0, 0, 13260, 13261, 5, 95, 0, 0, 13261, 13262, 7, 25, 0, 0, + 13262, 13263, 7, 3, 0, 0, 13263, 13264, 7, 11, 0, 0, 13264, 13265, 7, 11, + 0, 0, 13265, 13266, 7, 9, 0, 0, 13266, 13267, 7, 19, 0, 0, 13267, 13268, + 7, 8, 0, 0, 13268, 13269, 7, 4, 0, 0, 13269, 13270, 5, 95, 0, 0, 13270, + 13271, 7, 11, 0, 0, 13271, 13272, 7, 6, 0, 0, 13272, 13273, 7, 8, 0, 0, + 13273, 13274, 7, 7, 0, 0, 13274, 13275, 7, 12, 0, 0, 13275, 13276, 7, 22, + 0, 0, 13276, 13277, 7, 6, 0, 0, 13277, 13278, 7, 20, 0, 0, 13278, 2202, + 1, 0, 0, 0, 13279, 13280, 7, 24, 0, 0, 13280, 13281, 7, 7, 0, 0, 13281, + 13282, 7, 14, 0, 0, 13282, 13283, 7, 6, 0, 0, 13283, 13284, 7, 19, 0, 0, + 13284, 13285, 7, 8, 0, 0, 13285, 13286, 5, 95, 0, 0, 13286, 13287, 7, 4, + 0, 0, 13287, 13288, 7, 15, 0, 0, 13288, 13289, 7, 23, 0, 0, 13289, 2204, + 1, 0, 0, 0, 13290, 13291, 7, 24, 0, 0, 13291, 13292, 7, 7, 0, 0, 13292, + 13293, 7, 14, 0, 0, 13293, 13294, 7, 6, 0, 0, 13294, 13295, 7, 19, 0, 0, + 13295, 13296, 7, 8, 0, 0, 13296, 13297, 5, 95, 0, 0, 13297, 13298, 7, 6, + 0, 0, 13298, 13299, 7, 19, 0, 0, 13299, 13300, 5, 95, 0, 0, 13300, 13301, + 7, 11, 0, 0, 13301, 13302, 7, 6, 0, 0, 13302, 13303, 7, 8, 0, 0, 13303, + 13304, 7, 15, 0, 0, 13304, 13305, 7, 12, 0, 0, 13305, 13306, 7, 22, 0, + 0, 13306, 2206, 1, 0, 0, 0, 13307, 13308, 7, 24, 0, 0, 13308, 13309, 7, + 7, 0, 0, 13309, 13310, 7, 8, 0, 0, 13310, 13311, 7, 11, 0, 0, 13311, 13312, + 7, 15, 0, 0, 13312, 13313, 7, 19, 0, 0, 13313, 13314, 7, 12, 0, 0, 13314, + 2208, 1, 0, 0, 0, 13315, 13316, 7, 9, 0, 0, 13316, 13317, 7, 3, 0, 0, 13317, + 13318, 7, 15, 0, 0, 13318, 13319, 7, 6, 0, 0, 13319, 13320, 5, 95, 0, 0, + 13320, 13321, 7, 17, 0, 0, 13321, 13322, 7, 12, 0, 0, 13322, 13323, 7, + 6, 0, 0, 13323, 13324, 7, 15, 0, 0, 13324, 13325, 7, 5, 0, 0, 13325, 13326, + 5, 95, 0, 0, 13326, 13327, 7, 11, 0, 0, 13327, 13328, 7, 28, 0, 0, 13328, + 13329, 7, 5, 0, 0, 13329, 13330, 5, 95, 0, 0, 13330, 13331, 7, 6, 0, 0, + 13331, 13332, 7, 20, 0, 0, 13332, 13333, 7, 8, 0, 0, 13333, 13334, 7, 7, + 0, 0, 13334, 13335, 7, 3, 0, 0, 13335, 13336, 7, 4, 0, 0, 13336, 13337, + 5, 95, 0, 0, 13337, 13338, 7, 3, 0, 0, 13338, 13339, 7, 18, 0, 0, 13339, + 13340, 7, 6, 0, 0, 13340, 13341, 7, 7, 0, 0, 13341, 13342, 7, 8, 0, 0, + 13342, 13343, 5, 95, 0, 0, 13343, 13344, 7, 22, 0, 0, 13344, 13345, 7, + 6, 0, 0, 13345, 13346, 7, 15, 0, 0, 13346, 13347, 7, 4, 0, 0, 13347, 13348, + 7, 11, 0, 0, 13348, 2210, 1, 0, 0, 0, 13349, 13350, 7, 9, 0, 0, 13350, + 13351, 7, 7, 0, 0, 13351, 13352, 7, 7, 0, 0, 13352, 13353, 7, 21, 0, 0, + 13353, 13354, 7, 4, 0, 0, 13354, 13355, 7, 3, 0, 0, 13355, 13356, 7, 10, + 0, 0, 13356, 2212, 1, 0, 0, 0, 13357, 13358, 7, 9, 0, 0, 13358, 13359, + 7, 7, 0, 0, 13359, 13360, 7, 7, 0, 0, 13360, 13361, 7, 21, 0, 0, 13361, + 13362, 7, 19, 0, 0, 13362, 13363, 7, 18, 0, 0, 13363, 13364, 7, 10, 0, + 0, 13364, 13365, 7, 7, 0, 0, 13365, 13366, 7, 3, 0, 0, 13366, 13367, 7, + 8, 0, 0, 13367, 2214, 1, 0, 0, 0, 13368, 13369, 7, 9, 0, 0, 13369, 13370, + 7, 7, 0, 0, 13370, 13371, 7, 15, 0, 0, 13371, 13372, 7, 22, 0, 0, 13372, + 13373, 7, 20, 0, 0, 13373, 13374, 7, 6, 0, 0, 13374, 13375, 5, 95, 0, 0, + 13375, 13376, 7, 11, 0, 0, 13376, 13377, 7, 6, 0, 0, 13377, 13378, 7, 8, + 0, 0, 13378, 13379, 7, 15, 0, 0, 13379, 13380, 7, 12, 0, 0, 13380, 13381, + 7, 22, 0, 0, 13381, 2216, 1, 0, 0, 0, 13382, 13383, 7, 9, 0, 0, 13383, + 13384, 7, 15, 0, 0, 13384, 13385, 7, 6, 0, 0, 13385, 13386, 7, 20, 0, 0, + 13386, 13387, 7, 15, 0, 0, 13387, 13388, 7, 12, 0, 0, 13388, 2218, 1, 0, + 0, 0, 13389, 13390, 7, 10, 0, 0, 13390, 13391, 7, 7, 0, 0, 13391, 13392, + 7, 3, 0, 0, 13392, 13393, 7, 8, 0, 0, 13393, 13394, 7, 9, 0, 0, 13394, + 13395, 7, 7, 0, 0, 13395, 13396, 7, 7, 0, 0, 13396, 13397, 7, 21, 0, 0, + 13397, 2220, 1, 0, 0, 0, 13398, 13399, 7, 10, 0, 0, 13399, 2222, 1, 0, + 0, 0, 13400, 13401, 7, 26, 0, 0, 13401, 2224, 1, 0, 0, 0, 13402, 13403, + 5, 58, 0, 0, 13403, 13404, 5, 61, 0, 0, 13404, 2226, 1, 0, 0, 0, 13405, + 13406, 5, 43, 0, 0, 13406, 13407, 5, 61, 0, 0, 13407, 2228, 1, 0, 0, 0, + 13408, 13409, 5, 45, 0, 0, 13409, 13410, 5, 61, 0, 0, 13410, 2230, 1, 0, + 0, 0, 13411, 13412, 5, 42, 0, 0, 13412, 13413, 5, 61, 0, 0, 13413, 2232, + 1, 0, 0, 0, 13414, 13415, 5, 47, 0, 0, 13415, 13416, 5, 61, 0, 0, 13416, + 2234, 1, 0, 0, 0, 13417, 13418, 5, 37, 0, 0, 13418, 13419, 5, 61, 0, 0, + 13419, 2236, 1, 0, 0, 0, 13420, 13421, 5, 38, 0, 0, 13421, 13422, 5, 61, + 0, 0, 13422, 2238, 1, 0, 0, 0, 13423, 13424, 5, 94, 0, 0, 13424, 13425, + 5, 61, 0, 0, 13425, 2240, 1, 0, 0, 0, 13426, 13427, 5, 124, 0, 0, 13427, + 13428, 5, 61, 0, 0, 13428, 2242, 1, 0, 0, 0, 13429, 13430, 5, 42, 0, 0, + 13430, 2244, 1, 0, 0, 0, 13431, 13432, 5, 47, 0, 0, 13432, 2246, 1, 0, + 0, 0, 13433, 13434, 5, 37, 0, 0, 13434, 2248, 1, 0, 0, 0, 13435, 13436, + 5, 43, 0, 0, 13436, 2250, 1, 0, 0, 0, 13437, 13438, 5, 45, 0, 0, 13438, + 2252, 1, 0, 0, 0, 13439, 13440, 7, 4, 0, 0, 13440, 13441, 7, 15, 0, 0, + 13441, 13442, 7, 24, 0, 0, 13442, 2254, 1, 0, 0, 0, 13443, 13444, 7, 23, + 0, 0, 13444, 13445, 7, 19, 0, 0, 13445, 13446, 7, 4, 0, 0, 13446, 2256, + 1, 0, 0, 0, 13447, 13448, 5, 61, 0, 0, 13448, 2258, 1, 0, 0, 0, 13449, + 13450, 5, 62, 0, 0, 13450, 2260, 1, 0, 0, 0, 13451, 13452, 5, 60, 0, 0, + 13452, 2262, 1, 0, 0, 0, 13453, 13454, 5, 33, 0, 0, 13454, 2264, 1, 0, + 0, 0, 13455, 13456, 5, 126, 0, 0, 13456, 2266, 1, 0, 0, 0, 13457, 13458, + 5, 124, 0, 0, 13458, 2268, 1, 0, 0, 0, 13459, 13460, 5, 38, 0, 0, 13460, + 2270, 1, 0, 0, 0, 13461, 13462, 5, 94, 0, 0, 13462, 2272, 1, 0, 0, 0, 13463, + 13464, 5, 46, 0, 0, 13464, 2274, 1, 0, 0, 0, 13465, 13466, 5, 40, 0, 0, + 13466, 2276, 1, 0, 0, 0, 13467, 13468, 5, 41, 0, 0, 13468, 2278, 1, 0, + 0, 0, 13469, 13470, 5, 44, 0, 0, 13470, 2280, 1, 0, 0, 0, 13471, 13472, + 5, 59, 0, 0, 13472, 2282, 1, 0, 0, 0, 13473, 13474, 5, 64, 0, 0, 13474, + 2284, 1, 0, 0, 0, 13475, 13476, 5, 48, 0, 0, 13476, 2286, 1, 0, 0, 0, 13477, + 13478, 5, 49, 0, 0, 13478, 2288, 1, 0, 0, 0, 13479, 13480, 5, 50, 0, 0, + 13480, 2290, 1, 0, 0, 0, 13481, 13482, 5, 39, 0, 0, 13482, 2292, 1, 0, + 0, 0, 13483, 13484, 5, 34, 0, 0, 13484, 2294, 1, 0, 0, 0, 13485, 13486, + 5, 96, 0, 0, 13486, 2296, 1, 0, 0, 0, 13487, 13488, 5, 58, 0, 0, 13488, + 2298, 1, 0, 0, 0, 13489, 13493, 3, 2291, 1145, 0, 13490, 13493, 3, 2293, + 1146, 0, 13491, 13493, 3, 2295, 1147, 0, 13492, 13489, 1, 0, 0, 0, 13492, + 13490, 1, 0, 0, 0, 13492, 13491, 1, 0, 0, 0, 13493, 2300, 1, 0, 0, 0, 13494, + 13495, 5, 96, 0, 0, 13495, 13496, 3, 2333, 1166, 0, 13496, 13497, 5, 96, + 0, 0, 13497, 2302, 1, 0, 0, 0, 13498, 13500, 3, 2347, 1173, 0, 13499, 13498, + 1, 0, 0, 0, 13500, 13501, 1, 0, 0, 0, 13501, 13499, 1, 0, 0, 0, 13501, + 13502, 1, 0, 0, 0, 13502, 13503, 1, 0, 0, 0, 13503, 13504, 7, 29, 0, 0, + 13504, 2304, 1, 0, 0, 0, 13505, 13506, 7, 12, 0, 0, 13506, 13507, 3, 2341, + 1170, 0, 13507, 2306, 1, 0, 0, 0, 13508, 13512, 3, 2339, 1169, 0, 13509, + 13512, 3, 2341, 1170, 0, 13510, 13512, 3, 2343, 1171, 0, 13511, 13508, + 1, 0, 0, 0, 13511, 13509, 1, 0, 0, 0, 13511, 13510, 1, 0, 0, 0, 13512, + 2308, 1, 0, 0, 0, 13513, 13515, 3, 2347, 1173, 0, 13514, 13513, 1, 0, 0, + 0, 13515, 13516, 1, 0, 0, 0, 13516, 13514, 1, 0, 0, 0, 13516, 13517, 1, + 0, 0, 0, 13517, 2310, 1, 0, 0, 0, 13518, 13519, 7, 26, 0, 0, 13519, 13523, + 5, 39, 0, 0, 13520, 13521, 3, 2345, 1172, 0, 13521, 13522, 3, 2345, 1172, + 0, 13522, 13524, 1, 0, 0, 0, 13523, 13520, 1, 0, 0, 0, 13524, 13525, 1, + 0, 0, 0, 13525, 13523, 1, 0, 0, 0, 13525, 13526, 1, 0, 0, 0, 13526, 13527, + 1, 0, 0, 0, 13527, 13528, 5, 39, 0, 0, 13528, 13538, 1, 0, 0, 0, 13529, + 13530, 5, 48, 0, 0, 13530, 13531, 7, 26, 0, 0, 13531, 13533, 1, 0, 0, 0, + 13532, 13534, 3, 2345, 1172, 0, 13533, 13532, 1, 0, 0, 0, 13534, 13535, + 1, 0, 0, 0, 13535, 13533, 1, 0, 0, 0, 13535, 13536, 1, 0, 0, 0, 13536, + 13538, 1, 0, 0, 0, 13537, 13518, 1, 0, 0, 0, 13537, 13529, 1, 0, 0, 0, + 13538, 2312, 1, 0, 0, 0, 13539, 13541, 3, 2347, 1173, 0, 13540, 13539, + 1, 0, 0, 0, 13541, 13544, 1, 0, 0, 0, 13542, 13540, 1, 0, 0, 0, 13542, + 13543, 1, 0, 0, 0, 13543, 13545, 1, 0, 0, 0, 13544, 13542, 1, 0, 0, 0, + 13545, 13547, 5, 46, 0, 0, 13546, 13548, 3, 2347, 1173, 0, 13547, 13546, + 1, 0, 0, 0, 13548, 13549, 1, 0, 0, 0, 13549, 13547, 1, 0, 0, 0, 13549, + 13550, 1, 0, 0, 0, 13550, 13581, 1, 0, 0, 0, 13551, 13553, 3, 2347, 1173, + 0, 13552, 13551, 1, 0, 0, 0, 13553, 13554, 1, 0, 0, 0, 13554, 13552, 1, + 0, 0, 0, 13554, 13555, 1, 0, 0, 0, 13555, 13556, 1, 0, 0, 0, 13556, 13557, + 5, 46, 0, 0, 13557, 13558, 3, 2335, 1167, 0, 13558, 13581, 1, 0, 0, 0, + 13559, 13561, 3, 2347, 1173, 0, 13560, 13559, 1, 0, 0, 0, 13561, 13564, + 1, 0, 0, 0, 13562, 13560, 1, 0, 0, 0, 13562, 13563, 1, 0, 0, 0, 13563, + 13565, 1, 0, 0, 0, 13564, 13562, 1, 0, 0, 0, 13565, 13567, 5, 46, 0, 0, + 13566, 13568, 3, 2347, 1173, 0, 13567, 13566, 1, 0, 0, 0, 13568, 13569, + 1, 0, 0, 0, 13569, 13567, 1, 0, 0, 0, 13569, 13570, 1, 0, 0, 0, 13570, + 13571, 1, 0, 0, 0, 13571, 13572, 3, 2335, 1167, 0, 13572, 13581, 1, 0, + 0, 0, 13573, 13575, 3, 2347, 1173, 0, 13574, 13573, 1, 0, 0, 0, 13575, + 13576, 1, 0, 0, 0, 13576, 13574, 1, 0, 0, 0, 13576, 13577, 1, 0, 0, 0, + 13577, 13578, 1, 0, 0, 0, 13578, 13579, 3, 2335, 1167, 0, 13579, 13581, + 1, 0, 0, 0, 13580, 13542, 1, 0, 0, 0, 13580, 13552, 1, 0, 0, 0, 13580, + 13562, 1, 0, 0, 0, 13580, 13574, 1, 0, 0, 0, 13581, 2314, 1, 0, 0, 0, 13582, + 13583, 5, 92, 0, 0, 13583, 13584, 7, 12, 0, 0, 13584, 2316, 1, 0, 0, 0, + 13585, 13586, 3, 2349, 1174, 0, 13586, 2318, 1, 0, 0, 0, 13587, 13588, + 5, 95, 0, 0, 13588, 13589, 3, 2333, 1166, 0, 13589, 2320, 1, 0, 0, 0, 13590, + 13591, 5, 46, 0, 0, 13591, 13592, 3, 2337, 1168, 0, 13592, 2322, 1, 0, + 0, 0, 13593, 13594, 3, 2337, 1168, 0, 13594, 2324, 1, 0, 0, 0, 13595, 13596, + 3, 2343, 1171, 0, 13596, 2326, 1, 0, 0, 0, 13597, 13598, 3, 2283, 1141, + 0, 13598, 13599, 3, 2351, 1175, 0, 13599, 2328, 1, 0, 0, 0, 13600, 13607, + 3, 2283, 1141, 0, 13601, 13608, 3, 2307, 1153, 0, 13602, 13604, 7, 30, + 0, 0, 13603, 13602, 1, 0, 0, 0, 13604, 13605, 1, 0, 0, 0, 13605, 13603, + 1, 0, 0, 0, 13605, 13606, 1, 0, 0, 0, 13606, 13608, 1, 0, 0, 0, 13607, + 13601, 1, 0, 0, 0, 13607, 13603, 1, 0, 0, 0, 13608, 2330, 1, 0, 0, 0, 13609, + 13610, 3, 2283, 1141, 0, 13610, 13617, 3, 2283, 1141, 0, 13611, 13613, + 7, 30, 0, 0, 13612, 13611, 1, 0, 0, 0, 13613, 13614, 1, 0, 0, 0, 13614, + 13612, 1, 0, 0, 0, 13614, 13615, 1, 0, 0, 0, 13615, 13618, 1, 0, 0, 0, + 13616, 13618, 3, 2343, 1171, 0, 13617, 13612, 1, 0, 0, 0, 13617, 13616, + 1, 0, 0, 0, 13618, 2332, 1, 0, 0, 0, 13619, 13661, 3, 1493, 746, 0, 13620, + 13661, 3, 1495, 747, 0, 13621, 13661, 3, 1497, 748, 0, 13622, 13661, 3, + 451, 225, 0, 13623, 13661, 3, 1499, 749, 0, 13624, 13661, 3, 1501, 750, + 0, 13625, 13661, 3, 1503, 751, 0, 13626, 13661, 3, 1505, 752, 0, 13627, + 13661, 3, 1507, 753, 0, 13628, 13661, 3, 1509, 754, 0, 13629, 13661, 3, + 1511, 755, 0, 13630, 13661, 3, 1513, 756, 0, 13631, 13661, 3, 1515, 757, + 0, 13632, 13661, 3, 1517, 758, 0, 13633, 13661, 3, 1519, 759, 0, 13634, + 13661, 3, 1523, 761, 0, 13635, 13661, 3, 1525, 762, 0, 13636, 13661, 3, + 1527, 763, 0, 13637, 13661, 3, 1529, 764, 0, 13638, 13661, 3, 1531, 765, + 0, 13639, 13661, 3, 1533, 766, 0, 13640, 13661, 3, 1535, 767, 0, 13641, + 13661, 3, 1537, 768, 0, 13642, 13661, 3, 1539, 769, 0, 13643, 13661, 3, + 1541, 770, 0, 13644, 13661, 3, 1543, 771, 0, 13645, 13661, 3, 1545, 772, + 0, 13646, 13661, 3, 1547, 773, 0, 13647, 13661, 3, 1549, 774, 0, 13648, + 13661, 3, 1551, 775, 0, 13649, 13661, 3, 1553, 776, 0, 13650, 13661, 3, + 1555, 777, 0, 13651, 13661, 3, 1557, 778, 0, 13652, 13661, 3, 1559, 779, + 0, 13653, 13661, 3, 1561, 780, 0, 13654, 13661, 3, 1563, 781, 0, 13655, + 13661, 3, 1565, 782, 0, 13656, 13661, 3, 1567, 783, 0, 13657, 13661, 3, + 1569, 784, 0, 13658, 13661, 3, 1571, 785, 0, 13659, 13661, 3, 1573, 786, + 0, 13660, 13619, 1, 0, 0, 0, 13660, 13620, 1, 0, 0, 0, 13660, 13621, 1, + 0, 0, 0, 13660, 13622, 1, 0, 0, 0, 13660, 13623, 1, 0, 0, 0, 13660, 13624, + 1, 0, 0, 0, 13660, 13625, 1, 0, 0, 0, 13660, 13626, 1, 0, 0, 0, 13660, + 13627, 1, 0, 0, 0, 13660, 13628, 1, 0, 0, 0, 13660, 13629, 1, 0, 0, 0, + 13660, 13630, 1, 0, 0, 0, 13660, 13631, 1, 0, 0, 0, 13660, 13632, 1, 0, + 0, 0, 13660, 13633, 1, 0, 0, 0, 13660, 13634, 1, 0, 0, 0, 13660, 13635, + 1, 0, 0, 0, 13660, 13636, 1, 0, 0, 0, 13660, 13637, 1, 0, 0, 0, 13660, + 13638, 1, 0, 0, 0, 13660, 13639, 1, 0, 0, 0, 13660, 13640, 1, 0, 0, 0, + 13660, 13641, 1, 0, 0, 0, 13660, 13642, 1, 0, 0, 0, 13660, 13643, 1, 0, + 0, 0, 13660, 13644, 1, 0, 0, 0, 13660, 13645, 1, 0, 0, 0, 13660, 13646, + 1, 0, 0, 0, 13660, 13647, 1, 0, 0, 0, 13660, 13648, 1, 0, 0, 0, 13660, + 13649, 1, 0, 0, 0, 13660, 13650, 1, 0, 0, 0, 13660, 13651, 1, 0, 0, 0, + 13660, 13652, 1, 0, 0, 0, 13660, 13653, 1, 0, 0, 0, 13660, 13654, 1, 0, + 0, 0, 13660, 13655, 1, 0, 0, 0, 13660, 13656, 1, 0, 0, 0, 13660, 13657, + 1, 0, 0, 0, 13660, 13658, 1, 0, 0, 0, 13660, 13659, 1, 0, 0, 0, 13661, + 2334, 1, 0, 0, 0, 13662, 13664, 7, 7, 0, 0, 13663, 13665, 7, 31, 0, 0, + 13664, 13663, 1, 0, 0, 0, 13664, 13665, 1, 0, 0, 0, 13665, 13667, 1, 0, + 0, 0, 13666, 13668, 3, 2347, 1173, 0, 13667, 13666, 1, 0, 0, 0, 13668, + 13669, 1, 0, 0, 0, 13669, 13667, 1, 0, 0, 0, 13669, 13670, 1, 0, 0, 0, + 13670, 2336, 1, 0, 0, 0, 13671, 13673, 7, 32, 0, 0, 13672, 13671, 1, 0, + 0, 0, 13673, 13676, 1, 0, 0, 0, 13674, 13675, 1, 0, 0, 0, 13674, 13672, + 1, 0, 0, 0, 13675, 13678, 1, 0, 0, 0, 13676, 13674, 1, 0, 0, 0, 13677, + 13679, 7, 33, 0, 0, 13678, 13677, 1, 0, 0, 0, 13679, 13680, 1, 0, 0, 0, + 13680, 13681, 1, 0, 0, 0, 13680, 13678, 1, 0, 0, 0, 13681, 13685, 1, 0, + 0, 0, 13682, 13684, 7, 32, 0, 0, 13683, 13682, 1, 0, 0, 0, 13684, 13687, + 1, 0, 0, 0, 13685, 13683, 1, 0, 0, 0, 13685, 13686, 1, 0, 0, 0, 13686, + 2338, 1, 0, 0, 0, 13687, 13685, 1, 0, 0, 0, 13688, 13696, 5, 34, 0, 0, + 13689, 13690, 5, 92, 0, 0, 13690, 13695, 9, 0, 0, 0, 13691, 13692, 5, 34, + 0, 0, 13692, 13695, 5, 34, 0, 0, 13693, 13695, 8, 34, 0, 0, 13694, 13689, + 1, 0, 0, 0, 13694, 13691, 1, 0, 0, 0, 13694, 13693, 1, 0, 0, 0, 13695, + 13698, 1, 0, 0, 0, 13696, 13694, 1, 0, 0, 0, 13696, 13697, 1, 0, 0, 0, + 13697, 13699, 1, 0, 0, 0, 13698, 13696, 1, 0, 0, 0, 13699, 13700, 5, 34, + 0, 0, 13700, 2340, 1, 0, 0, 0, 13701, 13709, 5, 39, 0, 0, 13702, 13703, + 5, 92, 0, 0, 13703, 13708, 9, 0, 0, 0, 13704, 13705, 5, 39, 0, 0, 13705, + 13708, 5, 39, 0, 0, 13706, 13708, 8, 35, 0, 0, 13707, 13702, 1, 0, 0, 0, + 13707, 13704, 1, 0, 0, 0, 13707, 13706, 1, 0, 0, 0, 13708, 13711, 1, 0, + 0, 0, 13709, 13707, 1, 0, 0, 0, 13709, 13710, 1, 0, 0, 0, 13710, 13712, + 1, 0, 0, 0, 13711, 13709, 1, 0, 0, 0, 13712, 13713, 5, 39, 0, 0, 13713, + 2342, 1, 0, 0, 0, 13714, 13720, 5, 96, 0, 0, 13715, 13719, 8, 36, 0, 0, + 13716, 13717, 5, 96, 0, 0, 13717, 13719, 5, 96, 0, 0, 13718, 13715, 1, + 0, 0, 0, 13718, 13716, 1, 0, 0, 0, 13719, 13722, 1, 0, 0, 0, 13720, 13718, + 1, 0, 0, 0, 13720, 13721, 1, 0, 0, 0, 13721, 13723, 1, 0, 0, 0, 13722, + 13720, 1, 0, 0, 0, 13723, 13724, 5, 96, 0, 0, 13724, 2344, 1, 0, 0, 0, + 13725, 13726, 7, 37, 0, 0, 13726, 2346, 1, 0, 0, 0, 13727, 13728, 7, 38, + 0, 0, 13728, 2348, 1, 0, 0, 0, 13729, 13730, 7, 16, 0, 0, 13730, 13732, + 5, 39, 0, 0, 13731, 13733, 7, 39, 0, 0, 13732, 13731, 1, 0, 0, 0, 13733, + 13734, 1, 0, 0, 0, 13734, 13732, 1, 0, 0, 0, 13734, 13735, 1, 0, 0, 0, + 13735, 13736, 1, 0, 0, 0, 13736, 13737, 5, 39, 0, 0, 13737, 2350, 1, 0, + 0, 0, 13738, 13740, 7, 38, 0, 0, 13739, 13738, 1, 0, 0, 0, 13740, 13741, + 1, 0, 0, 0, 13741, 13739, 1, 0, 0, 0, 13741, 13742, 1, 0, 0, 0, 13742, + 13743, 1, 0, 0, 0, 13743, 13745, 5, 46, 0, 0, 13744, 13746, 7, 40, 0, 0, + 13745, 13744, 1, 0, 0, 0, 13746, 13747, 1, 0, 0, 0, 13747, 13745, 1, 0, + 0, 0, 13747, 13748, 1, 0, 0, 0, 13748, 13769, 1, 0, 0, 0, 13749, 13751, + 7, 37, 0, 0, 13750, 13749, 1, 0, 0, 0, 13751, 13754, 1, 0, 0, 0, 13752, + 13750, 1, 0, 0, 0, 13752, 13753, 1, 0, 0, 0, 13753, 13755, 1, 0, 0, 0, + 13754, 13752, 1, 0, 0, 0, 13755, 13759, 5, 58, 0, 0, 13756, 13758, 7, 37, + 0, 0, 13757, 13756, 1, 0, 0, 0, 13758, 13761, 1, 0, 0, 0, 13759, 13757, + 1, 0, 0, 0, 13759, 13760, 1, 0, 0, 0, 13760, 13762, 1, 0, 0, 0, 13761, + 13759, 1, 0, 0, 0, 13762, 13764, 5, 58, 0, 0, 13763, 13765, 7, 41, 0, 0, + 13764, 13763, 1, 0, 0, 0, 13765, 13766, 1, 0, 0, 0, 13766, 13764, 1, 0, + 0, 0, 13766, 13767, 1, 0, 0, 0, 13767, 13769, 1, 0, 0, 0, 13768, 13739, + 1, 0, 0, 0, 13768, 13752, 1, 0, 0, 0, 13769, 2352, 1, 0, 0, 0, 13770, 13771, + 9, 0, 0, 0, 13771, 13772, 1, 0, 0, 0, 13772, 13773, 6, 1176, 2, 0, 13773, + 2354, 1, 0, 0, 0, 51, 0, 2358, 2369, 2382, 2396, 2400, 2405, 2409, 2413, + 2419, 2423, 2425, 9278, 9305, 13492, 13501, 13511, 13516, 13525, 13535, + 13537, 13542, 13549, 13554, 13562, 13569, 13576, 13580, 13605, 13607, 13614, + 13617, 13660, 13664, 13669, 13674, 13680, 13685, 13694, 13696, 13707, 13709, + 13718, 13720, 13734, 13741, 13747, 13752, 13759, 13766, 13768, 3, 0, 1, + 0, 0, 2, 0, 0, 3, 0, + } + deserializer := antlr.NewATNDeserializer(nil) + staticData.atn = deserializer.Deserialize(staticData.serializedATN) + atn := staticData.atn + staticData.decisionToDFA = make([]*antlr.DFA, len(atn.DecisionToState)) + decisionToDFA := staticData.decisionToDFA + for index, state := range atn.DecisionToState { + decisionToDFA[index] = antlr.NewDFA(state, index) + } +} + +// MySqlLexerInit initializes any static state used to implement MySqlLexer. By default the +// static state used to implement the lexer is lazily initialized during the first call to +// NewMySqlLexer(). You can call this function if you wish to initialize the static state ahead +// of time. +func MySqlLexerInit() { + staticData := &MySqlLexerLexerStaticData + staticData.once.Do(mysqllexerLexerInit) +} + +// NewMySqlLexer produces a new lexer instance for the optional input antlr.CharStream. +func NewMySqlLexer(input antlr.CharStream) *MySqlLexer { + MySqlLexerInit() + l := new(MySqlLexer) + l.BaseLexer = antlr.NewBaseLexer(input) + staticData := &MySqlLexerLexerStaticData + l.Interpreter = antlr.NewLexerATNSimulator(l, staticData.atn, staticData.decisionToDFA, staticData.PredictionContextCache) + l.channelNames = staticData.ChannelNames + l.modeNames = staticData.ModeNames + l.RuleNames = staticData.RuleNames + l.LiteralNames = staticData.LiteralNames + l.SymbolicNames = staticData.SymbolicNames + l.GrammarFileName = "MySqlLexer.g4" + // TODO: l.EOF = antlr.TokenEOF + + return l +} + +// MySqlLexer tokens. +const ( + MySqlLexerSPACE = 1 + MySqlLexerSPEC_MYSQL_COMMENT = 2 + MySqlLexerCOMMENT_INPUT = 3 + MySqlLexerLINE_COMMENT = 4 + MySqlLexerADD = 5 + MySqlLexerALL = 6 + MySqlLexerALTER = 7 + MySqlLexerALWAYS = 8 + MySqlLexerANALYZE = 9 + MySqlLexerAND = 10 + MySqlLexerARRAY = 11 + MySqlLexerAS = 12 + MySqlLexerASC = 13 + MySqlLexerATTRIBUTE = 14 + MySqlLexerBEFORE = 15 + MySqlLexerBETWEEN = 16 + MySqlLexerBOTH = 17 + MySqlLexerBUCKETS = 18 + MySqlLexerBY = 19 + MySqlLexerCALL = 20 + MySqlLexerCASCADE = 21 + MySqlLexerCASE = 22 + MySqlLexerCAST = 23 + MySqlLexerCHANGE = 24 + MySqlLexerCHARACTER = 25 + MySqlLexerCHECK = 26 + MySqlLexerCOLLATE = 27 + MySqlLexerCOLUMN = 28 + MySqlLexerCONDITION = 29 + MySqlLexerCONSTRAINT = 30 + MySqlLexerCONTINUE = 31 + MySqlLexerCONVERT = 32 + MySqlLexerCREATE = 33 + MySqlLexerCROSS = 34 + MySqlLexerCURRENT = 35 + MySqlLexerCURRENT_ROLE = 36 + MySqlLexerCURRENT_USER = 37 + MySqlLexerCURSOR = 38 + MySqlLexerDATABASE = 39 + MySqlLexerDATABASES = 40 + MySqlLexerDECLARE = 41 + MySqlLexerDEFAULT = 42 + MySqlLexerDELAYED = 43 + MySqlLexerDELETE = 44 + MySqlLexerDESC = 45 + MySqlLexerDESCRIBE = 46 + MySqlLexerDETERMINISTIC = 47 + MySqlLexerDIAGNOSTICS = 48 + MySqlLexerDISTINCT = 49 + MySqlLexerDISTINCTROW = 50 + MySqlLexerDROP = 51 + MySqlLexerEACH = 52 + MySqlLexerELSE = 53 + MySqlLexerELSEIF = 54 + MySqlLexerEMPTY = 55 + MySqlLexerENCLOSED = 56 + MySqlLexerENFORCED = 57 + MySqlLexerESCAPED = 58 + MySqlLexerEXCEPT = 59 + MySqlLexerEXISTS = 60 + MySqlLexerEXIT = 61 + MySqlLexerEXPLAIN = 62 + MySqlLexerFALSE = 63 + MySqlLexerFETCH = 64 + MySqlLexerFOR = 65 + MySqlLexerFORCE = 66 + MySqlLexerFOREIGN = 67 + MySqlLexerFROM = 68 + MySqlLexerFULLTEXT = 69 + MySqlLexerGENERATED = 70 + MySqlLexerGET = 71 + MySqlLexerGRANT = 72 + MySqlLexerGROUP = 73 + MySqlLexerHAVING = 74 + MySqlLexerHIGH_PRIORITY = 75 + MySqlLexerHISTOGRAM = 76 + MySqlLexerIF = 77 + MySqlLexerIGNORE = 78 + MySqlLexerIGNORED = 79 + MySqlLexerIN = 80 + MySqlLexerINDEX = 81 + MySqlLexerINFILE = 82 + MySqlLexerINNER = 83 + MySqlLexerINOUT = 84 + MySqlLexerINSERT = 85 + MySqlLexerINTERVAL = 86 + MySqlLexerINTO = 87 + MySqlLexerIS = 88 + MySqlLexerITERATE = 89 + MySqlLexerJOIN = 90 + MySqlLexerKEY = 91 + MySqlLexerKEYS = 92 + MySqlLexerKILL = 93 + MySqlLexerLATERAL = 94 + MySqlLexerLEADING = 95 + MySqlLexerLEAVE = 96 + MySqlLexerLEFT = 97 + MySqlLexerLIKE = 98 + MySqlLexerLIMIT = 99 + MySqlLexerLINEAR = 100 + MySqlLexerLINES = 101 + MySqlLexerLOAD = 102 + MySqlLexerLOCK = 103 + MySqlLexerLOCKED = 104 + MySqlLexerLOOP = 105 + MySqlLexerLOW_PRIORITY = 106 + MySqlLexerMASTER_BIND = 107 + MySqlLexerMASTER_SSL_VERIFY_SERVER_CERT = 108 + MySqlLexerMATCH = 109 + MySqlLexerMAXVALUE = 110 + MySqlLexerMINVALUE = 111 + MySqlLexerMODIFIES = 112 + MySqlLexerNATURAL = 113 + MySqlLexerNOT = 114 + MySqlLexerNO_WRITE_TO_BINLOG = 115 + MySqlLexerNULL_LITERAL = 116 + MySqlLexerNUMBER = 117 + MySqlLexerON = 118 + MySqlLexerOPTIMIZE = 119 + MySqlLexerOPTION = 120 + MySqlLexerOPTIONAL = 121 + MySqlLexerOPTIONALLY = 122 + MySqlLexerOR = 123 + MySqlLexerORDER = 124 + MySqlLexerOUT = 125 + MySqlLexerOUTER = 126 + MySqlLexerOUTFILE = 127 + MySqlLexerOVER = 128 + MySqlLexerPARTITION = 129 + MySqlLexerPRIMARY = 130 + MySqlLexerPROCEDURE = 131 + MySqlLexerPURGE = 132 + MySqlLexerRANGE = 133 + MySqlLexerREAD = 134 + MySqlLexerREADS = 135 + MySqlLexerREFERENCES = 136 + MySqlLexerREGEXP = 137 + MySqlLexerRELEASE = 138 + MySqlLexerRENAME = 139 + MySqlLexerREPEAT = 140 + MySqlLexerREPLACE = 141 + MySqlLexerREQUIRE = 142 + MySqlLexerRESIGNAL = 143 + MySqlLexerRESTRICT = 144 + MySqlLexerRETAIN = 145 + MySqlLexerRETURN = 146 + MySqlLexerREVOKE = 147 + MySqlLexerRIGHT = 148 + MySqlLexerRLIKE = 149 + MySqlLexerSCHEMA = 150 + MySqlLexerSCHEMAS = 151 + MySqlLexerSELECT = 152 + MySqlLexerSET = 153 + MySqlLexerSEPARATOR = 154 + MySqlLexerSHOW = 155 + MySqlLexerSIGNAL = 156 + MySqlLexerSKIP_ = 157 + MySqlLexerSKIP_QUERY_REWRITE = 158 + MySqlLexerSPATIAL = 159 + MySqlLexerSQL = 160 + MySqlLexerSQLEXCEPTION = 161 + MySqlLexerSQLSTATE = 162 + MySqlLexerSQLWARNING = 163 + MySqlLexerSQL_BIG_RESULT = 164 + MySqlLexerSQL_CALC_FOUND_ROWS = 165 + MySqlLexerSQL_SMALL_RESULT = 166 + MySqlLexerSSL = 167 + MySqlLexerSTACKED = 168 + MySqlLexerSTARTING = 169 + MySqlLexerSTATEMENT = 170 + MySqlLexerSTRAIGHT_JOIN = 171 + MySqlLexerTABLE = 172 + MySqlLexerTERMINATED = 173 + MySqlLexerTHEN = 174 + MySqlLexerTO = 175 + MySqlLexerTRAILING = 176 + MySqlLexerTRIGGER = 177 + MySqlLexerTRUE = 178 + MySqlLexerUNDO = 179 + MySqlLexerUNION = 180 + MySqlLexerUNIQUE = 181 + MySqlLexerUNLOCK = 182 + MySqlLexerUNSIGNED = 183 + MySqlLexerUPDATE = 184 + MySqlLexerUSAGE = 185 + MySqlLexerUSE = 186 + MySqlLexerUSING = 187 + MySqlLexerVALUES = 188 + MySqlLexerWHEN = 189 + MySqlLexerWHERE = 190 + MySqlLexerWHILE = 191 + MySqlLexerWITH = 192 + MySqlLexerWRITE = 193 + MySqlLexerXOR = 194 + MySqlLexerZEROFILL = 195 + MySqlLexerTINYINT = 196 + MySqlLexerSMALLINT = 197 + MySqlLexerMEDIUMINT = 198 + MySqlLexerMIDDLEINT = 199 + MySqlLexerINT = 200 + MySqlLexerINT1 = 201 + MySqlLexerINT2 = 202 + MySqlLexerINT3 = 203 + MySqlLexerINT4 = 204 + MySqlLexerINT8 = 205 + MySqlLexerINTEGER = 206 + MySqlLexerBIGINT = 207 + MySqlLexerREAL = 208 + MySqlLexerDOUBLE = 209 + MySqlLexerPRECISION = 210 + MySqlLexerFLOAT = 211 + MySqlLexerFLOAT4 = 212 + MySqlLexerFLOAT8 = 213 + MySqlLexerDECIMAL = 214 + MySqlLexerDEC = 215 + MySqlLexerNUMERIC = 216 + MySqlLexerDATE = 217 + MySqlLexerTIME = 218 + MySqlLexerTIMESTAMP = 219 + MySqlLexerDATETIME = 220 + MySqlLexerYEAR = 221 + MySqlLexerCHAR = 222 + MySqlLexerVARCHAR = 223 + MySqlLexerNVARCHAR = 224 + MySqlLexerNATIONAL = 225 + MySqlLexerBINARY = 226 + MySqlLexerVARBINARY = 227 + MySqlLexerTINYBLOB = 228 + MySqlLexerBLOB = 229 + MySqlLexerMEDIUMBLOB = 230 + MySqlLexerLONG = 231 + MySqlLexerLONGBLOB = 232 + MySqlLexerTINYTEXT = 233 + MySqlLexerTEXT = 234 + MySqlLexerMEDIUMTEXT = 235 + MySqlLexerLONGTEXT = 236 + MySqlLexerENUM = 237 + MySqlLexerVARYING = 238 + MySqlLexerSERIAL = 239 + MySqlLexerVECTOR = 240 + MySqlLexerYEAR_MONTH = 241 + MySqlLexerDAY_HOUR = 242 + MySqlLexerDAY_MINUTE = 243 + MySqlLexerDAY_SECOND = 244 + MySqlLexerHOUR_MINUTE = 245 + MySqlLexerHOUR_SECOND = 246 + MySqlLexerMINUTE_SECOND = 247 + MySqlLexerSECOND_MICROSECOND = 248 + MySqlLexerMINUTE_MICROSECOND = 249 + MySqlLexerHOUR_MICROSECOND = 250 + MySqlLexerDAY_MICROSECOND = 251 + MySqlLexerJSON_ARRAY = 252 + MySqlLexerJSON_ARRAYAGG = 253 + MySqlLexerJSON_ARRAY_APPEND = 254 + MySqlLexerJSON_ARRAY_INSERT = 255 + MySqlLexerJSON_CONTAINS = 256 + MySqlLexerJSON_CONTAINS_PATH = 257 + MySqlLexerJSON_DEPTH = 258 + MySqlLexerJSON_EXTRACT = 259 + MySqlLexerJSON_INSERT = 260 + MySqlLexerJSON_KEYS = 261 + MySqlLexerJSON_LENGTH = 262 + MySqlLexerJSON_MERGE = 263 + MySqlLexerJSON_MERGE_PATCH = 264 + MySqlLexerJSON_MERGE_PRESERVE = 265 + MySqlLexerJSON_OBJECT = 266 + MySqlLexerJSON_OBJECTAGG = 267 + MySqlLexerJSON_OVERLAPS = 268 + MySqlLexerJSON_PRETTY = 269 + MySqlLexerJSON_QUOTE = 270 + MySqlLexerJSON_REMOVE = 271 + MySqlLexerJSON_REPLACE = 272 + MySqlLexerJSON_SCHEMA_VALID = 273 + MySqlLexerJSON_SCHEMA_VALIDATION_REPORT = 274 + MySqlLexerJSON_SEARCH = 275 + MySqlLexerJSON_SET = 276 + MySqlLexerJSON_STORAGE_FREE = 277 + MySqlLexerJSON_STORAGE_SIZE = 278 + MySqlLexerJSON_TABLE = 279 + MySqlLexerJSON_TYPE = 280 + MySqlLexerJSON_UNQUOTE = 281 + MySqlLexerJSON_VALID = 282 + MySqlLexerJSON_VALUE = 283 + MySqlLexerNESTED = 284 + MySqlLexerORDINALITY = 285 + MySqlLexerPATH = 286 + MySqlLexerAVG = 287 + MySqlLexerBIT_AND = 288 + MySqlLexerBIT_OR = 289 + MySqlLexerBIT_XOR = 290 + MySqlLexerCOUNT = 291 + MySqlLexerCUME_DIST = 292 + MySqlLexerDENSE_RANK = 293 + MySqlLexerFIRST_VALUE = 294 + MySqlLexerGROUP_CONCAT = 295 + MySqlLexerLAG = 296 + MySqlLexerLAST_VALUE = 297 + MySqlLexerLEAD = 298 + MySqlLexerMAX = 299 + MySqlLexerMIN = 300 + MySqlLexerNTILE = 301 + MySqlLexerNTH_VALUE = 302 + MySqlLexerPERCENT_RANK = 303 + MySqlLexerRANK = 304 + MySqlLexerROW_NUMBER = 305 + MySqlLexerSTD = 306 + MySqlLexerSTDDEV = 307 + MySqlLexerSTDDEV_POP = 308 + MySqlLexerSTDDEV_SAMP = 309 + MySqlLexerSUM = 310 + MySqlLexerVAR_POP = 311 + MySqlLexerVAR_SAMP = 312 + MySqlLexerVARIANCE = 313 + MySqlLexerCURRENT_DATE = 314 + MySqlLexerCURRENT_TIME = 315 + MySqlLexerCURRENT_TIMESTAMP = 316 + MySqlLexerLOCALTIME = 317 + MySqlLexerCURDATE = 318 + MySqlLexerCURTIME = 319 + MySqlLexerDATE_ADD = 320 + MySqlLexerDATE_SUB = 321 + MySqlLexerEXTRACT = 322 + MySqlLexerLOCALTIMESTAMP = 323 + MySqlLexerNOW = 324 + MySqlLexerPOSITION = 325 + MySqlLexerSUBSTR = 326 + MySqlLexerSUBSTRING = 327 + MySqlLexerSYSDATE = 328 + MySqlLexerTRIM = 329 + MySqlLexerUTC_DATE = 330 + MySqlLexerUTC_TIME = 331 + MySqlLexerUTC_TIMESTAMP = 332 + MySqlLexerACCOUNT = 333 + MySqlLexerACTION = 334 + MySqlLexerAFTER = 335 + MySqlLexerAGGREGATE = 336 + MySqlLexerALGORITHM = 337 + MySqlLexerANY = 338 + MySqlLexerAT = 339 + MySqlLexerAUTHORS = 340 + MySqlLexerAUTOCOMMIT = 341 + MySqlLexerAUTOEXTEND_SIZE = 342 + MySqlLexerAUTO_INCREMENT = 343 + MySqlLexerAVG_ROW_LENGTH = 344 + MySqlLexerBEGIN = 345 + MySqlLexerBINLOG = 346 + MySqlLexerBIT = 347 + MySqlLexerBLOCK = 348 + MySqlLexerBOOL = 349 + MySqlLexerBOOLEAN = 350 + MySqlLexerBTREE = 351 + MySqlLexerCACHE = 352 + MySqlLexerCASCADED = 353 + MySqlLexerCHAIN = 354 + MySqlLexerCHANGED = 355 + MySqlLexerCHANNEL = 356 + MySqlLexerCHECKSUM = 357 + MySqlLexerPAGE_CHECKSUM = 358 + MySqlLexerCIPHER = 359 + MySqlLexerCLASS_ORIGIN = 360 + MySqlLexerCLIENT = 361 + MySqlLexerCLOSE = 362 + MySqlLexerCLUSTERING = 363 + MySqlLexerCOALESCE = 364 + MySqlLexerCODE = 365 + MySqlLexerCOLUMNS = 366 + MySqlLexerCOLUMN_FORMAT = 367 + MySqlLexerCOLUMN_NAME = 368 + MySqlLexerCOMMENT = 369 + MySqlLexerCOMMIT = 370 + MySqlLexerCOMPACT = 371 + MySqlLexerCOMPLETION = 372 + MySqlLexerCOMPRESSED = 373 + MySqlLexerCOMPRESSION = 374 + MySqlLexerCONCURRENT = 375 + MySqlLexerCONNECT = 376 + MySqlLexerCONNECTION = 377 + MySqlLexerCONSISTENT = 378 + MySqlLexerCONSTRAINT_CATALOG = 379 + MySqlLexerCONSTRAINT_SCHEMA = 380 + MySqlLexerCONSTRAINT_NAME = 381 + MySqlLexerCONTAINS = 382 + MySqlLexerCONTEXT = 383 + MySqlLexerCONTRIBUTORS = 384 + MySqlLexerCOPY = 385 + MySqlLexerCPU = 386 + MySqlLexerCYCLE = 387 + MySqlLexerCURSOR_NAME = 388 + MySqlLexerDATA = 389 + MySqlLexerDATAFILE = 390 + MySqlLexerDEALLOCATE = 391 + MySqlLexerDEFAULT_AUTH = 392 + MySqlLexerDEFINER = 393 + MySqlLexerDELAY_KEY_WRITE = 394 + MySqlLexerDES_KEY_FILE = 395 + MySqlLexerDIRECTORY = 396 + MySqlLexerDISABLE = 397 + MySqlLexerDISCARD = 398 + MySqlLexerDISK = 399 + MySqlLexerDO = 400 + MySqlLexerDUMPFILE = 401 + MySqlLexerDUPLICATE = 402 + MySqlLexerDYNAMIC = 403 + MySqlLexerENABLE = 404 + MySqlLexerENCRYPTED = 405 + MySqlLexerENCRYPTION = 406 + MySqlLexerENCRYPTION_KEY_ID = 407 + MySqlLexerEND = 408 + MySqlLexerENDS = 409 + MySqlLexerENGINE = 410 + MySqlLexerENGINES = 411 + MySqlLexerERROR = 412 + MySqlLexerERRORS = 413 + MySqlLexerESCAPE = 414 + MySqlLexerEVEN = 415 + MySqlLexerEVENT = 416 + MySqlLexerEVENTS = 417 + MySqlLexerEVERY = 418 + MySqlLexerEXCHANGE = 419 + MySqlLexerEXCLUSIVE = 420 + MySqlLexerEXPIRE = 421 + MySqlLexerEXPORT = 422 + MySqlLexerEXTENDED = 423 + MySqlLexerEXTENT_SIZE = 424 + MySqlLexerFAILED_LOGIN_ATTEMPTS = 425 + MySqlLexerFAST = 426 + MySqlLexerFAULTS = 427 + MySqlLexerFIELDS = 428 + MySqlLexerFILE_BLOCK_SIZE = 429 + MySqlLexerFILTER = 430 + MySqlLexerFIRST = 431 + MySqlLexerFIXED = 432 + MySqlLexerFLUSH = 433 + MySqlLexerFOLLOWING = 434 + MySqlLexerFOLLOWS = 435 + MySqlLexerFOUND = 436 + MySqlLexerFULL = 437 + MySqlLexerFUNCTION = 438 + MySqlLexerGENERAL = 439 + MySqlLexerGLOBAL = 440 + MySqlLexerGRANTS = 441 + MySqlLexerGROUP_REPLICATION = 442 + MySqlLexerHANDLER = 443 + MySqlLexerHASH = 444 + MySqlLexerHELP = 445 + MySqlLexerHISTORY = 446 + MySqlLexerHOST = 447 + MySqlLexerHOSTS = 448 + MySqlLexerIDENTIFIED = 449 + MySqlLexerIGNORE_SERVER_IDS = 450 + MySqlLexerIMPORT = 451 + MySqlLexerINCREMENT = 452 + MySqlLexerINDEXES = 453 + MySqlLexerINITIAL_SIZE = 454 + MySqlLexerINPLACE = 455 + MySqlLexerINSERT_METHOD = 456 + MySqlLexerINSTALL = 457 + MySqlLexerINSTANCE = 458 + MySqlLexerINSTANT = 459 + MySqlLexerINVISIBLE = 460 + MySqlLexerINVOKER = 461 + MySqlLexerIO = 462 + MySqlLexerIO_THREAD = 463 + MySqlLexerIPC = 464 + MySqlLexerISOLATION = 465 + MySqlLexerISSUER = 466 + MySqlLexerJSON = 467 + MySqlLexerKEY_BLOCK_SIZE = 468 + MySqlLexerLANGUAGE = 469 + MySqlLexerLAST = 470 + MySqlLexerLEAVES = 471 + MySqlLexerLESS = 472 + MySqlLexerLEVEL = 473 + MySqlLexerLIST = 474 + MySqlLexerLOCAL = 475 + MySqlLexerLOGFILE = 476 + MySqlLexerLOGS = 477 + MySqlLexerMASTER = 478 + MySqlLexerMASTER_AUTO_POSITION = 479 + MySqlLexerMASTER_CONNECT_RETRY = 480 + MySqlLexerMASTER_DELAY = 481 + MySqlLexerMASTER_HEARTBEAT_PERIOD = 482 + MySqlLexerMASTER_HOST = 483 + MySqlLexerMASTER_LOG_FILE = 484 + MySqlLexerMASTER_LOG_POS = 485 + MySqlLexerMASTER_PASSWORD = 486 + MySqlLexerMASTER_PORT = 487 + MySqlLexerMASTER_RETRY_COUNT = 488 + MySqlLexerMASTER_SSL = 489 + MySqlLexerMASTER_SSL_CA = 490 + MySqlLexerMASTER_SSL_CAPATH = 491 + MySqlLexerMASTER_SSL_CERT = 492 + MySqlLexerMASTER_SSL_CIPHER = 493 + MySqlLexerMASTER_SSL_CRL = 494 + MySqlLexerMASTER_SSL_CRLPATH = 495 + MySqlLexerMASTER_SSL_KEY = 496 + MySqlLexerMASTER_TLS_VERSION = 497 + MySqlLexerMASTER_USER = 498 + MySqlLexerMAX_CONNECTIONS_PER_HOUR = 499 + MySqlLexerMAX_QUERIES_PER_HOUR = 500 + MySqlLexerMAX_ROWS = 501 + MySqlLexerMAX_SIZE = 502 + MySqlLexerMAX_UPDATES_PER_HOUR = 503 + MySqlLexerMAX_USER_CONNECTIONS = 504 + MySqlLexerMEDIUM = 505 + MySqlLexerMEMBER = 506 + MySqlLexerMERGE = 507 + MySqlLexerMESSAGE_TEXT = 508 + MySqlLexerMID = 509 + MySqlLexerMIGRATE = 510 + MySqlLexerMIN_ROWS = 511 + MySqlLexerMODE = 512 + MySqlLexerMODIFY = 513 + MySqlLexerMUTEX = 514 + MySqlLexerMYSQL = 515 + MySqlLexerMYSQL_ERRNO = 516 + MySqlLexerNAME = 517 + MySqlLexerNAMES = 518 + MySqlLexerNCHAR = 519 + MySqlLexerNEVER = 520 + MySqlLexerNEXT = 521 + MySqlLexerNO = 522 + MySqlLexerNOCACHE = 523 + MySqlLexerNOCOPY = 524 + MySqlLexerNOCYCLE = 525 + MySqlLexerNOMAXVALUE = 526 + MySqlLexerNOMINVALUE = 527 + MySqlLexerNOWAIT = 528 + MySqlLexerNODEGROUP = 529 + MySqlLexerNONE = 530 + MySqlLexerODBC = 531 + MySqlLexerOFFLINE = 532 + MySqlLexerOFFSET = 533 + MySqlLexerOF = 534 + MySqlLexerOJ = 535 + MySqlLexerOLD_PASSWORD = 536 + MySqlLexerONE = 537 + MySqlLexerONLINE = 538 + MySqlLexerONLY = 539 + MySqlLexerOPEN = 540 + MySqlLexerOPTIMIZER_COSTS = 541 + MySqlLexerOPTIONS = 542 + MySqlLexerOWNER = 543 + MySqlLexerPACK_KEYS = 544 + MySqlLexerPAGE = 545 + MySqlLexerPAGE_COMPRESSED = 546 + MySqlLexerPAGE_COMPRESSION_LEVEL = 547 + MySqlLexerPARSER = 548 + MySqlLexerPARTIAL = 549 + MySqlLexerPARTITIONING = 550 + MySqlLexerPARTITIONS = 551 + MySqlLexerPASSWORD = 552 + MySqlLexerPASSWORD_LOCK_TIME = 553 + MySqlLexerPHASE = 554 + MySqlLexerPLUGIN = 555 + MySqlLexerPLUGIN_DIR = 556 + MySqlLexerPLUGINS = 557 + MySqlLexerPORT = 558 + MySqlLexerPRECEDES = 559 + MySqlLexerPRECEDING = 560 + MySqlLexerPREPARE = 561 + MySqlLexerPRESERVE = 562 + MySqlLexerPREV = 563 + MySqlLexerPROCESSLIST = 564 + MySqlLexerPROFILE = 565 + MySqlLexerPROFILES = 566 + MySqlLexerPROXY = 567 + MySqlLexerQUERY = 568 + MySqlLexerQUICK = 569 + MySqlLexerREBUILD = 570 + MySqlLexerRECOVER = 571 + MySqlLexerRECURSIVE = 572 + MySqlLexerREDO_BUFFER_SIZE = 573 + MySqlLexerREDUNDANT = 574 + MySqlLexerRELAY = 575 + MySqlLexerRELAY_LOG_FILE = 576 + MySqlLexerRELAY_LOG_POS = 577 + MySqlLexerRELAYLOG = 578 + MySqlLexerREMOVE = 579 + MySqlLexerREORGANIZE = 580 + MySqlLexerREPAIR = 581 + MySqlLexerREPLICATE_DO_DB = 582 + MySqlLexerREPLICATE_DO_TABLE = 583 + MySqlLexerREPLICATE_IGNORE_DB = 584 + MySqlLexerREPLICATE_IGNORE_TABLE = 585 + MySqlLexerREPLICATE_REWRITE_DB = 586 + MySqlLexerREPLICATE_WILD_DO_TABLE = 587 + MySqlLexerREPLICATE_WILD_IGNORE_TABLE = 588 + MySqlLexerREPLICATION = 589 + MySqlLexerRESET = 590 + MySqlLexerRESTART = 591 + MySqlLexerRESUME = 592 + MySqlLexerRETURNED_SQLSTATE = 593 + MySqlLexerRETURNING = 594 + MySqlLexerRETURNS = 595 + MySqlLexerREUSE = 596 + MySqlLexerROLE = 597 + MySqlLexerROLLBACK = 598 + MySqlLexerROLLUP = 599 + MySqlLexerROTATE = 600 + MySqlLexerROW = 601 + MySqlLexerROWS = 602 + MySqlLexerROW_FORMAT = 603 + MySqlLexerRTREE = 604 + MySqlLexerSAVEPOINT = 605 + MySqlLexerSCHEDULE = 606 + MySqlLexerSECURITY = 607 + MySqlLexerSEQUENCE = 608 + MySqlLexerSERVER = 609 + MySqlLexerSESSION = 610 + MySqlLexerSHARE = 611 + MySqlLexerSHARED = 612 + MySqlLexerSIGNED = 613 + MySqlLexerSIMPLE = 614 + MySqlLexerSLAVE = 615 + MySqlLexerSLOW = 616 + MySqlLexerSNAPSHOT = 617 + MySqlLexerSOCKET = 618 + MySqlLexerSOME = 619 + MySqlLexerSONAME = 620 + MySqlLexerSOUNDS = 621 + MySqlLexerSOURCE = 622 + MySqlLexerSQL_AFTER_GTIDS = 623 + MySqlLexerSQL_AFTER_MTS_GAPS = 624 + MySqlLexerSQL_BEFORE_GTIDS = 625 + MySqlLexerSQL_BUFFER_RESULT = 626 + MySqlLexerSQL_CACHE = 627 + MySqlLexerSQL_NO_CACHE = 628 + MySqlLexerSQL_THREAD = 629 + MySqlLexerSTART = 630 + MySqlLexerSTARTS = 631 + MySqlLexerSTATS_AUTO_RECALC = 632 + MySqlLexerSTATS_PERSISTENT = 633 + MySqlLexerSTATS_SAMPLE_PAGES = 634 + MySqlLexerSTATUS = 635 + MySqlLexerSTOP = 636 + MySqlLexerSTORAGE = 637 + MySqlLexerSTORED = 638 + MySqlLexerSTRING = 639 + MySqlLexerSUBCLASS_ORIGIN = 640 + MySqlLexerSUBJECT = 641 + MySqlLexerSUBPARTITION = 642 + MySqlLexerSUBPARTITIONS = 643 + MySqlLexerSUSPEND = 644 + MySqlLexerSWAPS = 645 + MySqlLexerSWITCHES = 646 + MySqlLexerTABLE_NAME = 647 + MySqlLexerTABLESPACE = 648 + MySqlLexerTABLE_TYPE = 649 + MySqlLexerTEMPORARY = 650 + MySqlLexerTEMPTABLE = 651 + MySqlLexerTHAN = 652 + MySqlLexerTRADITIONAL = 653 + MySqlLexerTRANSACTION = 654 + MySqlLexerTRANSACTIONAL = 655 + MySqlLexerTRIGGERS = 656 + MySqlLexerTRUNCATE = 657 + MySqlLexerUNBOUNDED = 658 + MySqlLexerUNDEFINED = 659 + MySqlLexerUNDOFILE = 660 + MySqlLexerUNDO_BUFFER_SIZE = 661 + MySqlLexerUNINSTALL = 662 + MySqlLexerUNKNOWN = 663 + MySqlLexerUNTIL = 664 + MySqlLexerUPGRADE = 665 + MySqlLexerUSER = 666 + MySqlLexerUSE_FRM = 667 + MySqlLexerUSER_RESOURCES = 668 + MySqlLexerVALIDATION = 669 + MySqlLexerVALUE = 670 + MySqlLexerVARIABLES = 671 + MySqlLexerVIEW = 672 + MySqlLexerVIRTUAL = 673 + MySqlLexerVISIBLE = 674 + MySqlLexerWAIT = 675 + MySqlLexerWARNINGS = 676 + MySqlLexerWINDOW = 677 + MySqlLexerWITHOUT = 678 + MySqlLexerWORK = 679 + MySqlLexerWRAPPER = 680 + MySqlLexerX509 = 681 + MySqlLexerXA = 682 + MySqlLexerXML = 683 + MySqlLexerYES = 684 + MySqlLexerEUR = 685 + MySqlLexerUSA = 686 + MySqlLexerJIS = 687 + MySqlLexerISO = 688 + MySqlLexerINTERNAL = 689 + MySqlLexerQUARTER = 690 + MySqlLexerMONTH = 691 + MySqlLexerDAY = 692 + MySqlLexerHOUR = 693 + MySqlLexerMINUTE = 694 + MySqlLexerWEEK = 695 + MySqlLexerSECOND = 696 + MySqlLexerMICROSECOND = 697 + MySqlLexerADMIN = 698 + MySqlLexerAPPLICATION_PASSWORD_ADMIN = 699 + MySqlLexerAUDIT_ABORT_EXEMPT = 700 + MySqlLexerAUDIT_ADMIN = 701 + MySqlLexerAUTHENTICATION_POLICY_ADMIN = 702 + MySqlLexerBACKUP_ADMIN = 703 + MySqlLexerBINLOG_ADMIN = 704 + MySqlLexerBINLOG_ENCRYPTION_ADMIN = 705 + MySqlLexerCLONE_ADMIN = 706 + MySqlLexerCONNECTION_ADMIN = 707 + MySqlLexerENCRYPTION_KEY_ADMIN = 708 + MySqlLexerEXECUTE = 709 + MySqlLexerFILE = 710 + MySqlLexerFIREWALL_ADMIN = 711 + MySqlLexerFIREWALL_EXEMPT = 712 + MySqlLexerFIREWALL_USER = 713 + MySqlLexerFLUSH_OPTIMIZER_COSTS = 714 + MySqlLexerFLUSH_STATUS = 715 + MySqlLexerFLUSH_TABLES = 716 + MySqlLexerFLUSH_USER_RESOURCES = 717 + MySqlLexerGROUP_REPLICATION_ADMIN = 718 + MySqlLexerINNODB_REDO_LOG_ARCHIVE = 719 + MySqlLexerINNODB_REDO_LOG_ENABLE = 720 + MySqlLexerINVOKE = 721 + MySqlLexerLAMBDA = 722 + MySqlLexerNDB_STORED_USER = 723 + MySqlLexerPASSWORDLESS_USER_ADMIN = 724 + MySqlLexerPERSIST_RO_VARIABLES_ADMIN = 725 + MySqlLexerPRIVILEGES = 726 + MySqlLexerPROCESS = 727 + MySqlLexerRELOAD = 728 + MySqlLexerREPLICATION_APPLIER = 729 + MySqlLexerREPLICATION_SLAVE_ADMIN = 730 + MySqlLexerRESOURCE_GROUP_ADMIN = 731 + MySqlLexerRESOURCE_GROUP_USER = 732 + MySqlLexerROLE_ADMIN = 733 + MySqlLexerROUTINE = 734 + MySqlLexerS3 = 735 + MySqlLexerSERVICE_CONNECTION_ADMIN = 736 + MySqlLexerSESSION_VARIABLES_ADMIN = 737 + MySqlLexerSET_USER_ID = 738 + MySqlLexerSHOW_ROUTINE = 739 + MySqlLexerSHUTDOWN = 740 + MySqlLexerSUPER = 741 + MySqlLexerSYSTEM_VARIABLES_ADMIN = 742 + MySqlLexerTABLES = 743 + MySqlLexerTABLE_ENCRYPTION_ADMIN = 744 + MySqlLexerVERSION_TOKEN_ADMIN = 745 + MySqlLexerXA_RECOVER_ADMIN = 746 + MySqlLexerARMSCII8 = 747 + MySqlLexerASCII = 748 + MySqlLexerBIG5 = 749 + MySqlLexerCP1250 = 750 + MySqlLexerCP1251 = 751 + MySqlLexerCP1256 = 752 + MySqlLexerCP1257 = 753 + MySqlLexerCP850 = 754 + MySqlLexerCP852 = 755 + MySqlLexerCP866 = 756 + MySqlLexerCP932 = 757 + MySqlLexerDEC8 = 758 + MySqlLexerEUCJPMS = 759 + MySqlLexerEUCKR = 760 + MySqlLexerGB18030 = 761 + MySqlLexerGB2312 = 762 + MySqlLexerGBK = 763 + MySqlLexerGEOSTD8 = 764 + MySqlLexerGREEK = 765 + MySqlLexerHEBREW = 766 + MySqlLexerHP8 = 767 + MySqlLexerKEYBCS2 = 768 + MySqlLexerKOI8R = 769 + MySqlLexerKOI8U = 770 + MySqlLexerLATIN1 = 771 + MySqlLexerLATIN2 = 772 + MySqlLexerLATIN5 = 773 + MySqlLexerLATIN7 = 774 + MySqlLexerMACCE = 775 + MySqlLexerMACROMAN = 776 + MySqlLexerSJIS = 777 + MySqlLexerSWE7 = 778 + MySqlLexerTIS620 = 779 + MySqlLexerUCS2 = 780 + MySqlLexerUJIS = 781 + MySqlLexerUTF16 = 782 + MySqlLexerUTF16LE = 783 + MySqlLexerUTF32 = 784 + MySqlLexerUTF8 = 785 + MySqlLexerUTF8MB3 = 786 + MySqlLexerUTF8MB4 = 787 + MySqlLexerARCHIVE = 788 + MySqlLexerBLACKHOLE = 789 + MySqlLexerCSV = 790 + MySqlLexerFEDERATED = 791 + MySqlLexerINNODB = 792 + MySqlLexerMEMORY = 793 + MySqlLexerMRG_MYISAM = 794 + MySqlLexerMYISAM = 795 + MySqlLexerNDB = 796 + MySqlLexerNDBCLUSTER = 797 + MySqlLexerPERFORMANCE_SCHEMA = 798 + MySqlLexerTOKUDB = 799 + MySqlLexerREPEATABLE = 800 + MySqlLexerCOMMITTED = 801 + MySqlLexerUNCOMMITTED = 802 + MySqlLexerSERIALIZABLE = 803 + MySqlLexerGEOMETRYCOLLECTION = 804 + MySqlLexerGEOMCOLLECTION = 805 + MySqlLexerGEOMETRY = 806 + MySqlLexerLINESTRING = 807 + MySqlLexerMULTILINESTRING = 808 + MySqlLexerMULTIPOINT = 809 + MySqlLexerMULTIPOLYGON = 810 + MySqlLexerPOINT = 811 + MySqlLexerPOLYGON = 812 + MySqlLexerABS = 813 + MySqlLexerACOS = 814 + MySqlLexerADDDATE = 815 + MySqlLexerADDTIME = 816 + MySqlLexerAES_DECRYPT = 817 + MySqlLexerAES_ENCRYPT = 818 + MySqlLexerAREA = 819 + MySqlLexerASBINARY = 820 + MySqlLexerASIN = 821 + MySqlLexerASTEXT = 822 + MySqlLexerASWKB = 823 + MySqlLexerASWKT = 824 + MySqlLexerASYMMETRIC_DECRYPT = 825 + MySqlLexerASYMMETRIC_DERIVE = 826 + MySqlLexerASYMMETRIC_ENCRYPT = 827 + MySqlLexerASYMMETRIC_SIGN = 828 + MySqlLexerASYMMETRIC_VERIFY = 829 + MySqlLexerATAN = 830 + MySqlLexerATAN2 = 831 + MySqlLexerBENCHMARK = 832 + MySqlLexerBIN = 833 + MySqlLexerBIT_COUNT = 834 + MySqlLexerBIT_LENGTH = 835 + MySqlLexerBUFFER = 836 + MySqlLexerCATALOG_NAME = 837 + MySqlLexerCEIL = 838 + MySqlLexerCEILING = 839 + MySqlLexerCENTROID = 840 + MySqlLexerCHARACTER_LENGTH = 841 + MySqlLexerCHARSET = 842 + MySqlLexerCHAR_LENGTH = 843 + MySqlLexerCOERCIBILITY = 844 + MySqlLexerCOLLATION = 845 + MySqlLexerCOMPRESS = 846 + MySqlLexerCONCAT = 847 + MySqlLexerCONCAT_WS = 848 + MySqlLexerCONNECTION_ID = 849 + MySqlLexerCONV = 850 + MySqlLexerCONVERT_TZ = 851 + MySqlLexerCOS = 852 + MySqlLexerCOT = 853 + MySqlLexerCRC32 = 854 + MySqlLexerCREATE_ASYMMETRIC_PRIV_KEY = 855 + MySqlLexerCREATE_ASYMMETRIC_PUB_KEY = 856 + MySqlLexerCREATE_DH_PARAMETERS = 857 + MySqlLexerCREATE_DIGEST = 858 + MySqlLexerCROSSES = 859 + MySqlLexerDATEDIFF = 860 + MySqlLexerDATE_FORMAT = 861 + MySqlLexerDAYNAME = 862 + MySqlLexerDAYOFMONTH = 863 + MySqlLexerDAYOFWEEK = 864 + MySqlLexerDAYOFYEAR = 865 + MySqlLexerDECODE = 866 + MySqlLexerDEGREES = 867 + MySqlLexerDES_DECRYPT = 868 + MySqlLexerDES_ENCRYPT = 869 + MySqlLexerDIMENSION = 870 + MySqlLexerDISJOINT = 871 + MySqlLexerDISTANCE = 872 + MySqlLexerELT = 873 + MySqlLexerENCODE = 874 + MySqlLexerENCRYPT = 875 + MySqlLexerENDPOINT = 876 + MySqlLexerENGINE_ATTRIBUTE = 877 + MySqlLexerENVELOPE = 878 + MySqlLexerEQUALS = 879 + MySqlLexerEXP = 880 + MySqlLexerEXPORT_SET = 881 + MySqlLexerEXTERIORRING = 882 + MySqlLexerEXTRACTVALUE = 883 + MySqlLexerFIELD = 884 + MySqlLexerFIND_IN_SET = 885 + MySqlLexerFLOOR = 886 + MySqlLexerFORMAT = 887 + MySqlLexerFOUND_ROWS = 888 + MySqlLexerFROM_BASE64 = 889 + MySqlLexerFROM_DAYS = 890 + MySqlLexerFROM_UNIXTIME = 891 + MySqlLexerGEOMCOLLFROMTEXT = 892 + MySqlLexerGEOMCOLLFROMWKB = 893 + MySqlLexerGEOMETRYCOLLECTIONFROMTEXT = 894 + MySqlLexerGEOMETRYCOLLECTIONFROMWKB = 895 + MySqlLexerGEOMETRYFROMTEXT = 896 + MySqlLexerGEOMETRYFROMWKB = 897 + MySqlLexerGEOMETRYN = 898 + MySqlLexerGEOMETRYTYPE = 899 + MySqlLexerGEOMFROMTEXT = 900 + MySqlLexerGEOMFROMWKB = 901 + MySqlLexerGET_FORMAT = 902 + MySqlLexerGET_LOCK = 903 + MySqlLexerGLENGTH = 904 + MySqlLexerGREATEST = 905 + MySqlLexerGTID_SUBSET = 906 + MySqlLexerGTID_SUBTRACT = 907 + MySqlLexerHEX = 908 + MySqlLexerIFNULL = 909 + MySqlLexerINET6_ATON = 910 + MySqlLexerINET6_NTOA = 911 + MySqlLexerINET_ATON = 912 + MySqlLexerINET_NTOA = 913 + MySqlLexerINSTR = 914 + MySqlLexerINTERIORRINGN = 915 + MySqlLexerINTERSECTS = 916 + MySqlLexerISCLOSED = 917 + MySqlLexerISEMPTY = 918 + MySqlLexerISNULL = 919 + MySqlLexerISSIMPLE = 920 + MySqlLexerIS_FREE_LOCK = 921 + MySqlLexerIS_IPV4 = 922 + MySqlLexerIS_IPV4_COMPAT = 923 + MySqlLexerIS_IPV4_MAPPED = 924 + MySqlLexerIS_IPV6 = 925 + MySqlLexerIS_USED_LOCK = 926 + MySqlLexerLAST_INSERT_ID = 927 + MySqlLexerLCASE = 928 + MySqlLexerLEAST = 929 + MySqlLexerLENGTH = 930 + MySqlLexerLINEFROMTEXT = 931 + MySqlLexerLINEFROMWKB = 932 + MySqlLexerLINESTRINGFROMTEXT = 933 + MySqlLexerLINESTRINGFROMWKB = 934 + MySqlLexerLN = 935 + MySqlLexerLOAD_FILE = 936 + MySqlLexerLOCATE = 937 + MySqlLexerLOG = 938 + MySqlLexerLOG10 = 939 + MySqlLexerLOG2 = 940 + MySqlLexerLOWER = 941 + MySqlLexerLPAD = 942 + MySqlLexerLTRIM = 943 + MySqlLexerMAKEDATE = 944 + MySqlLexerMAKETIME = 945 + MySqlLexerMAKE_SET = 946 + MySqlLexerMASTER_POS_WAIT = 947 + MySqlLexerMBRCONTAINS = 948 + MySqlLexerMBRDISJOINT = 949 + MySqlLexerMBREQUAL = 950 + MySqlLexerMBRINTERSECTS = 951 + MySqlLexerMBROVERLAPS = 952 + MySqlLexerMBRTOUCHES = 953 + MySqlLexerMBRWITHIN = 954 + MySqlLexerMD5 = 955 + MySqlLexerMLINEFROMTEXT = 956 + MySqlLexerMLINEFROMWKB = 957 + MySqlLexerMONTHNAME = 958 + MySqlLexerMPOINTFROMTEXT = 959 + MySqlLexerMPOINTFROMWKB = 960 + MySqlLexerMPOLYFROMTEXT = 961 + MySqlLexerMPOLYFROMWKB = 962 + MySqlLexerMULTILINESTRINGFROMTEXT = 963 + MySqlLexerMULTILINESTRINGFROMWKB = 964 + MySqlLexerMULTIPOINTFROMTEXT = 965 + MySqlLexerMULTIPOINTFROMWKB = 966 + MySqlLexerMULTIPOLYGONFROMTEXT = 967 + MySqlLexerMULTIPOLYGONFROMWKB = 968 + MySqlLexerNAME_CONST = 969 + MySqlLexerNULLIF = 970 + MySqlLexerNUMGEOMETRIES = 971 + MySqlLexerNUMINTERIORRINGS = 972 + MySqlLexerNUMPOINTS = 973 + MySqlLexerOCT = 974 + MySqlLexerOCTET_LENGTH = 975 + MySqlLexerORD = 976 + MySqlLexerOVERLAPS = 977 + MySqlLexerPERIOD_ADD = 978 + MySqlLexerPERIOD_DIFF = 979 + MySqlLexerPI = 980 + MySqlLexerPOINTFROMTEXT = 981 + MySqlLexerPOINTFROMWKB = 982 + MySqlLexerPOINTN = 983 + MySqlLexerPOLYFROMTEXT = 984 + MySqlLexerPOLYFROMWKB = 985 + MySqlLexerPOLYGONFROMTEXT = 986 + MySqlLexerPOLYGONFROMWKB = 987 + MySqlLexerPOW = 988 + MySqlLexerPOWER = 989 + MySqlLexerQUOTE = 990 + MySqlLexerRADIANS = 991 + MySqlLexerRAND = 992 + MySqlLexerRANDOM = 993 + MySqlLexerRANDOM_BYTES = 994 + MySqlLexerRELEASE_LOCK = 995 + MySqlLexerREVERSE = 996 + MySqlLexerROUND = 997 + MySqlLexerROW_COUNT = 998 + MySqlLexerRPAD = 999 + MySqlLexerRTRIM = 1000 + MySqlLexerSEC_TO_TIME = 1001 + MySqlLexerSECONDARY_ENGINE_ATTRIBUTE = 1002 + MySqlLexerSESSION_USER = 1003 + MySqlLexerSHA = 1004 + MySqlLexerSHA1 = 1005 + MySqlLexerSHA2 = 1006 + MySqlLexerSCHEMA_NAME = 1007 + MySqlLexerSIGN = 1008 + MySqlLexerSIN = 1009 + MySqlLexerSLEEP = 1010 + MySqlLexerSOUNDEX = 1011 + MySqlLexerSQL_THREAD_WAIT_AFTER_GTIDS = 1012 + MySqlLexerSQRT = 1013 + MySqlLexerSRID = 1014 + MySqlLexerSTARTPOINT = 1015 + MySqlLexerSTRCMP = 1016 + MySqlLexerSTR_TO_DATE = 1017 + MySqlLexerST_AREA = 1018 + MySqlLexerST_ASBINARY = 1019 + MySqlLexerST_ASTEXT = 1020 + MySqlLexerST_ASWKB = 1021 + MySqlLexerST_ASWKT = 1022 + MySqlLexerST_BUFFER = 1023 + MySqlLexerST_CENTROID = 1024 + MySqlLexerST_CONTAINS = 1025 + MySqlLexerST_CROSSES = 1026 + MySqlLexerST_DIFFERENCE = 1027 + MySqlLexerST_DIMENSION = 1028 + MySqlLexerST_DISJOINT = 1029 + MySqlLexerST_DISTANCE = 1030 + MySqlLexerST_ENDPOINT = 1031 + MySqlLexerST_ENVELOPE = 1032 + MySqlLexerST_EQUALS = 1033 + MySqlLexerST_EXTERIORRING = 1034 + MySqlLexerST_GEOMCOLLFROMTEXT = 1035 + MySqlLexerST_GEOMCOLLFROMTXT = 1036 + MySqlLexerST_GEOMCOLLFROMWKB = 1037 + MySqlLexerST_GEOMETRYCOLLECTIONFROMTEXT = 1038 + MySqlLexerST_GEOMETRYCOLLECTIONFROMWKB = 1039 + MySqlLexerST_GEOMETRYFROMTEXT = 1040 + MySqlLexerST_GEOMETRYFROMWKB = 1041 + MySqlLexerST_GEOMETRYN = 1042 + MySqlLexerST_GEOMETRYTYPE = 1043 + MySqlLexerST_GEOMFROMTEXT = 1044 + MySqlLexerST_GEOMFROMWKB = 1045 + MySqlLexerST_INTERIORRINGN = 1046 + MySqlLexerST_INTERSECTION = 1047 + MySqlLexerST_INTERSECTS = 1048 + MySqlLexerST_ISCLOSED = 1049 + MySqlLexerST_ISEMPTY = 1050 + MySqlLexerST_ISSIMPLE = 1051 + MySqlLexerST_LINEFROMTEXT = 1052 + MySqlLexerST_LINEFROMWKB = 1053 + MySqlLexerST_LINESTRINGFROMTEXT = 1054 + MySqlLexerST_LINESTRINGFROMWKB = 1055 + MySqlLexerST_NUMGEOMETRIES = 1056 + MySqlLexerST_NUMINTERIORRING = 1057 + MySqlLexerST_NUMINTERIORRINGS = 1058 + MySqlLexerST_NUMPOINTS = 1059 + MySqlLexerST_OVERLAPS = 1060 + MySqlLexerST_POINTFROMTEXT = 1061 + MySqlLexerST_POINTFROMWKB = 1062 + MySqlLexerST_POINTN = 1063 + MySqlLexerST_POLYFROMTEXT = 1064 + MySqlLexerST_POLYFROMWKB = 1065 + MySqlLexerST_POLYGONFROMTEXT = 1066 + MySqlLexerST_POLYGONFROMWKB = 1067 + MySqlLexerST_SRID = 1068 + MySqlLexerST_STARTPOINT = 1069 + MySqlLexerST_SYMDIFFERENCE = 1070 + MySqlLexerST_TOUCHES = 1071 + MySqlLexerST_UNION = 1072 + MySqlLexerST_WITHIN = 1073 + MySqlLexerST_X = 1074 + MySqlLexerST_Y = 1075 + MySqlLexerSTRING_TO_VECTOR = 1076 + MySqlLexerSUBDATE = 1077 + MySqlLexerSUBSTRING_INDEX = 1078 + MySqlLexerSUBTIME = 1079 + MySqlLexerSYSTEM_USER = 1080 + MySqlLexerTAN = 1081 + MySqlLexerTIMEDIFF = 1082 + MySqlLexerTIMESTAMPADD = 1083 + MySqlLexerTIMESTAMPDIFF = 1084 + MySqlLexerTIME_FORMAT = 1085 + MySqlLexerTIME_TO_SEC = 1086 + MySqlLexerTOUCHES = 1087 + MySqlLexerTO_BASE64 = 1088 + MySqlLexerTO_DAYS = 1089 + MySqlLexerTO_SECONDS = 1090 + MySqlLexerTP_CONNECTION_ADMIN = 1091 + MySqlLexerUCASE = 1092 + MySqlLexerUNCOMPRESS = 1093 + MySqlLexerUNCOMPRESSED_LENGTH = 1094 + MySqlLexerUNHEX = 1095 + MySqlLexerUNIX_TIMESTAMP = 1096 + MySqlLexerUPDATEXML = 1097 + MySqlLexerUPPER = 1098 + MySqlLexerUUID = 1099 + MySqlLexerUUID_SHORT = 1100 + MySqlLexerVALIDATE_PASSWORD_STRENGTH = 1101 + MySqlLexerVECTOR_DIM = 1102 + MySqlLexerVECTOR_TO_STRING = 1103 + MySqlLexerVERSION = 1104 + MySqlLexerWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS = 1105 + MySqlLexerWEEKDAY = 1106 + MySqlLexerWEEKOFYEAR = 1107 + MySqlLexerWEIGHT_STRING = 1108 + MySqlLexerWITHIN = 1109 + MySqlLexerYEARWEEK = 1110 + MySqlLexerY_FUNCTION = 1111 + MySqlLexerX_FUNCTION = 1112 + MySqlLexerVAR_ASSIGN = 1113 + MySqlLexerPLUS_ASSIGN = 1114 + MySqlLexerMINUS_ASSIGN = 1115 + MySqlLexerMULT_ASSIGN = 1116 + MySqlLexerDIV_ASSIGN = 1117 + MySqlLexerMOD_ASSIGN = 1118 + MySqlLexerAND_ASSIGN = 1119 + MySqlLexerXOR_ASSIGN = 1120 + MySqlLexerOR_ASSIGN = 1121 + MySqlLexerSTAR = 1122 + MySqlLexerDIVIDE = 1123 + MySqlLexerMODULE = 1124 + MySqlLexerPLUS = 1125 + MySqlLexerMINUS = 1126 + MySqlLexerDIV = 1127 + MySqlLexerMOD = 1128 + MySqlLexerEQUAL_SYMBOL = 1129 + MySqlLexerGREATER_SYMBOL = 1130 + MySqlLexerLESS_SYMBOL = 1131 + MySqlLexerEXCLAMATION_SYMBOL = 1132 + MySqlLexerBIT_NOT_OP = 1133 + MySqlLexerBIT_OR_OP = 1134 + MySqlLexerBIT_AND_OP = 1135 + MySqlLexerBIT_XOR_OP = 1136 + MySqlLexerDOT = 1137 + MySqlLexerLR_BRACKET = 1138 + MySqlLexerRR_BRACKET = 1139 + MySqlLexerCOMMA = 1140 + MySqlLexerSEMI = 1141 + MySqlLexerAT_SIGN = 1142 + MySqlLexerZERO_DECIMAL = 1143 + MySqlLexerONE_DECIMAL = 1144 + MySqlLexerTWO_DECIMAL = 1145 + MySqlLexerSINGLE_QUOTE_SYMB = 1146 + MySqlLexerDOUBLE_QUOTE_SYMB = 1147 + MySqlLexerREVERSE_QUOTE_SYMB = 1148 + MySqlLexerCOLON_SYMB = 1149 + MySqlLexerCHARSET_REVERSE_QOUTE_STRING = 1150 + MySqlLexerFILESIZE_LITERAL = 1151 + MySqlLexerSTART_NATIONAL_STRING_LITERAL = 1152 + MySqlLexerSTRING_LITERAL = 1153 + MySqlLexerDECIMAL_LITERAL = 1154 + MySqlLexerHEXADECIMAL_LITERAL = 1155 + MySqlLexerREAL_LITERAL = 1156 + MySqlLexerNULL_SPEC_LITERAL = 1157 + MySqlLexerBIT_STRING = 1158 + MySqlLexerSTRING_CHARSET_NAME = 1159 + MySqlLexerDOT_ID = 1160 + MySqlLexerID = 1161 + MySqlLexerREVERSE_QUOTE_ID = 1162 + MySqlLexerHOST_IP_ADDRESS = 1163 + MySqlLexerLOCAL_ID = 1164 + MySqlLexerGLOBAL_ID = 1165 + MySqlLexerERROR_RECONGNIGION = 1166 +) + +// MySqlLexer escapedChannels. +const ( + MySqlLexerMYSQLCOMMENT = 2 + MySqlLexerERRORCHANNEL = 3 +) diff --git a/lib/antlr/generated/mysql_parser.go b/lib/antlr/generated/mysql_parser.go new file mode 100644 index 00000000..2a3ccb1a --- /dev/null +++ b/lib/antlr/generated/mysql_parser.go @@ -0,0 +1,130975 @@ +// Code generated from MySqlParser.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package generated // MySqlParser +import ( + "fmt" + "strconv" + "sync" + + "github.com/antlr4-go/antlr/v4" +) + +// Suppress unused import errors +var _ = fmt.Printf +var _ = strconv.Itoa +var _ = sync.Once{} + +type MySqlParser struct { + *antlr.BaseParser +} + +var MySqlParserParserStaticData struct { + once sync.Once + serializedATN []int32 + LiteralNames []string + SymbolicNames []string + RuleNames []string + PredictionContextCache *antlr.PredictionContextCache + atn *antlr.ATN + decisionToDFA []*antlr.DFA +} + +func mysqlparserParserInit() { + staticData := &MySqlParserParserStaticData + staticData.LiteralNames = []string{ + "", "", "", "", "", "'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'", "'VECTOR'", "'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'", "", "'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'", "'DISTANCE'", "'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'", "'STRING_TO_VECTOR'", "'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'", + "'VECTOR_DIM'", "'VECTOR_TO_STRING'", "'VERSION'", "'WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS'", + "'WEEKDAY'", "'WEEKOFYEAR'", "'WEIGHT_STRING'", "'WITHIN'", "'YEARWEEK'", + "'Y'", "'X'", "':='", "'+='", "'-='", "'*='", "'/='", "'%='", "'&='", + "'^='", "'|='", "'*'", "'/'", "'%'", "'+'", "'-'", "'DIV'", "'MOD'", + "'='", "'>'", "'<'", "'!'", "'~'", "'|'", "'&'", "'^'", "'.'", "'('", + "')'", "','", "';'", "'@'", "'0'", "'1'", "'2'", "'''", "'\"'", "'`'", + "':'", + } + staticData.SymbolicNames = []string{ + "", "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", + "VECTOR", "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", "DISTANCE", "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", "STRING_TO_VECTOR", "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", + "VECTOR_DIM", "VECTOR_TO_STRING", "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", + } + staticData.RuleNames = []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", + } + staticData.PredictionContextCache = antlr.NewPredictionContextCache() + staticData.serializedATN = []int32{ + 4, 1, 1166, 7478, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, + 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, + 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, + 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, + 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, + 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, + 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, + 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, + 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, 46, 2, + 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, 2, 52, + 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, 57, 7, + 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, 7, 62, + 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7, 67, 2, + 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, 72, 2, 73, + 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2, 78, 7, + 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83, 7, 83, + 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, 7, 88, 2, + 89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 2, 93, 7, 93, 2, 94, + 7, 94, 2, 95, 7, 95, 2, 96, 7, 96, 2, 97, 7, 97, 2, 98, 7, 98, 2, 99, 7, + 99, 2, 100, 7, 100, 2, 101, 7, 101, 2, 102, 7, 102, 2, 103, 7, 103, 2, + 104, 7, 104, 2, 105, 7, 105, 2, 106, 7, 106, 2, 107, 7, 107, 2, 108, 7, + 108, 2, 109, 7, 109, 2, 110, 7, 110, 2, 111, 7, 111, 2, 112, 7, 112, 2, + 113, 7, 113, 2, 114, 7, 114, 2, 115, 7, 115, 2, 116, 7, 116, 2, 117, 7, + 117, 2, 118, 7, 118, 2, 119, 7, 119, 2, 120, 7, 120, 2, 121, 7, 121, 2, + 122, 7, 122, 2, 123, 7, 123, 2, 124, 7, 124, 2, 125, 7, 125, 2, 126, 7, + 126, 2, 127, 7, 127, 2, 128, 7, 128, 2, 129, 7, 129, 2, 130, 7, 130, 2, + 131, 7, 131, 2, 132, 7, 132, 2, 133, 7, 133, 2, 134, 7, 134, 2, 135, 7, + 135, 2, 136, 7, 136, 2, 137, 7, 137, 2, 138, 7, 138, 2, 139, 7, 139, 2, + 140, 7, 140, 2, 141, 7, 141, 2, 142, 7, 142, 2, 143, 7, 143, 2, 144, 7, + 144, 2, 145, 7, 145, 2, 146, 7, 146, 2, 147, 7, 147, 2, 148, 7, 148, 2, + 149, 7, 149, 2, 150, 7, 150, 2, 151, 7, 151, 2, 152, 7, 152, 2, 153, 7, + 153, 2, 154, 7, 154, 2, 155, 7, 155, 2, 156, 7, 156, 2, 157, 7, 157, 2, + 158, 7, 158, 2, 159, 7, 159, 2, 160, 7, 160, 2, 161, 7, 161, 2, 162, 7, + 162, 2, 163, 7, 163, 2, 164, 7, 164, 2, 165, 7, 165, 2, 166, 7, 166, 2, + 167, 7, 167, 2, 168, 7, 168, 2, 169, 7, 169, 2, 170, 7, 170, 2, 171, 7, + 171, 2, 172, 7, 172, 2, 173, 7, 173, 2, 174, 7, 174, 2, 175, 7, 175, 2, + 176, 7, 176, 2, 177, 7, 177, 2, 178, 7, 178, 2, 179, 7, 179, 2, 180, 7, + 180, 2, 181, 7, 181, 2, 182, 7, 182, 2, 183, 7, 183, 2, 184, 7, 184, 2, + 185, 7, 185, 2, 186, 7, 186, 2, 187, 7, 187, 2, 188, 7, 188, 2, 189, 7, + 189, 2, 190, 7, 190, 2, 191, 7, 191, 2, 192, 7, 192, 2, 193, 7, 193, 2, + 194, 7, 194, 2, 195, 7, 195, 2, 196, 7, 196, 2, 197, 7, 197, 2, 198, 7, + 198, 2, 199, 7, 199, 2, 200, 7, 200, 2, 201, 7, 201, 2, 202, 7, 202, 2, + 203, 7, 203, 2, 204, 7, 204, 2, 205, 7, 205, 2, 206, 7, 206, 2, 207, 7, + 207, 2, 208, 7, 208, 2, 209, 7, 209, 2, 210, 7, 210, 2, 211, 7, 211, 2, + 212, 7, 212, 2, 213, 7, 213, 2, 214, 7, 214, 2, 215, 7, 215, 2, 216, 7, + 216, 2, 217, 7, 217, 2, 218, 7, 218, 2, 219, 7, 219, 2, 220, 7, 220, 2, + 221, 7, 221, 2, 222, 7, 222, 2, 223, 7, 223, 2, 224, 7, 224, 2, 225, 7, + 225, 2, 226, 7, 226, 2, 227, 7, 227, 2, 228, 7, 228, 2, 229, 7, 229, 2, + 230, 7, 230, 2, 231, 7, 231, 2, 232, 7, 232, 2, 233, 7, 233, 2, 234, 7, + 234, 2, 235, 7, 235, 2, 236, 7, 236, 2, 237, 7, 237, 2, 238, 7, 238, 2, + 239, 7, 239, 2, 240, 7, 240, 2, 241, 7, 241, 2, 242, 7, 242, 2, 243, 7, + 243, 2, 244, 7, 244, 2, 245, 7, 245, 2, 246, 7, 246, 2, 247, 7, 247, 2, + 248, 7, 248, 2, 249, 7, 249, 2, 250, 7, 250, 2, 251, 7, 251, 2, 252, 7, + 252, 2, 253, 7, 253, 2, 254, 7, 254, 2, 255, 7, 255, 2, 256, 7, 256, 2, + 257, 7, 257, 2, 258, 7, 258, 2, 259, 7, 259, 2, 260, 7, 260, 2, 261, 7, + 261, 2, 262, 7, 262, 2, 263, 7, 263, 2, 264, 7, 264, 2, 265, 7, 265, 2, + 266, 7, 266, 2, 267, 7, 267, 2, 268, 7, 268, 2, 269, 7, 269, 2, 270, 7, + 270, 2, 271, 7, 271, 2, 272, 7, 272, 2, 273, 7, 273, 2, 274, 7, 274, 2, + 275, 7, 275, 2, 276, 7, 276, 2, 277, 7, 277, 2, 278, 7, 278, 2, 279, 7, + 279, 2, 280, 7, 280, 2, 281, 7, 281, 2, 282, 7, 282, 2, 283, 7, 283, 2, + 284, 7, 284, 2, 285, 7, 285, 2, 286, 7, 286, 2, 287, 7, 287, 2, 288, 7, + 288, 2, 289, 7, 289, 2, 290, 7, 290, 2, 291, 7, 291, 2, 292, 7, 292, 2, + 293, 7, 293, 2, 294, 7, 294, 2, 295, 7, 295, 2, 296, 7, 296, 2, 297, 7, + 297, 2, 298, 7, 298, 2, 299, 7, 299, 2, 300, 7, 300, 2, 301, 7, 301, 2, + 302, 7, 302, 2, 303, 7, 303, 2, 304, 7, 304, 2, 305, 7, 305, 2, 306, 7, + 306, 2, 307, 7, 307, 2, 308, 7, 308, 2, 309, 7, 309, 2, 310, 7, 310, 2, + 311, 7, 311, 2, 312, 7, 312, 2, 313, 7, 313, 2, 314, 7, 314, 2, 315, 7, + 315, 2, 316, 7, 316, 2, 317, 7, 317, 2, 318, 7, 318, 2, 319, 7, 319, 2, + 320, 7, 320, 2, 321, 7, 321, 2, 322, 7, 322, 2, 323, 7, 323, 2, 324, 7, + 324, 2, 325, 7, 325, 2, 326, 7, 326, 2, 327, 7, 327, 2, 328, 7, 328, 2, + 329, 7, 329, 2, 330, 7, 330, 2, 331, 7, 331, 2, 332, 7, 332, 2, 333, 7, + 333, 2, 334, 7, 334, 2, 335, 7, 335, 2, 336, 7, 336, 2, 337, 7, 337, 2, + 338, 7, 338, 2, 339, 7, 339, 2, 340, 7, 340, 2, 341, 7, 341, 2, 342, 7, + 342, 2, 343, 7, 343, 2, 344, 7, 344, 2, 345, 7, 345, 2, 346, 7, 346, 2, + 347, 7, 347, 2, 348, 7, 348, 2, 349, 7, 349, 2, 350, 7, 350, 2, 351, 7, + 351, 2, 352, 7, 352, 2, 353, 7, 353, 2, 354, 7, 354, 2, 355, 7, 355, 2, + 356, 7, 356, 2, 357, 7, 357, 2, 358, 7, 358, 2, 359, 7, 359, 2, 360, 7, + 360, 1, 0, 3, 0, 724, 8, 0, 1, 0, 1, 0, 3, 0, 728, 8, 0, 1, 0, 1, 0, 1, + 1, 1, 1, 1, 1, 3, 1, 735, 8, 1, 1, 1, 3, 1, 738, 8, 1, 1, 1, 5, 1, 741, + 8, 1, 10, 1, 12, 1, 744, 9, 1, 1, 1, 1, 1, 1, 1, 3, 1, 749, 8, 1, 1, 1, + 3, 1, 752, 8, 1, 1, 1, 3, 1, 755, 8, 1, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, + 2, 1, 2, 3, 2, 764, 8, 2, 1, 3, 1, 3, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, + 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, + 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, + 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 3, 4, 806, 8, 4, 1, + 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, + 5, 3, 5, 821, 8, 5, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, + 6, 3, 6, 832, 8, 6, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, + 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 3, 7, 849, 8, 7, 1, 8, 1, 8, 1, + 8, 3, 8, 854, 8, 8, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, + 9, 1, 9, 1, 9, 1, 9, 1, 9, 3, 9, 869, 8, 9, 1, 10, 1, 10, 1, 10, 1, 10, + 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, + 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, + 3, 10, 896, 8, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 3, + 11, 905, 8, 11, 1, 12, 1, 12, 1, 12, 3, 12, 910, 8, 12, 1, 12, 1, 12, 5, + 12, 914, 8, 12, 10, 12, 12, 12, 917, 9, 12, 1, 13, 1, 13, 3, 13, 921, 8, + 13, 1, 13, 1, 13, 3, 13, 925, 8, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, + 1, 13, 1, 13, 3, 13, 934, 8, 13, 1, 13, 3, 13, 937, 8, 13, 1, 13, 3, 13, + 940, 8, 13, 1, 13, 1, 13, 3, 13, 944, 8, 13, 1, 13, 1, 13, 1, 13, 1, 14, + 1, 14, 3, 14, 951, 8, 14, 1, 14, 3, 14, 954, 8, 14, 1, 14, 1, 14, 1, 14, + 3, 14, 959, 8, 14, 1, 14, 1, 14, 1, 14, 1, 14, 5, 14, 965, 8, 14, 10, 14, + 12, 14, 968, 9, 14, 1, 14, 1, 14, 3, 14, 972, 8, 14, 1, 14, 1, 14, 1, 14, + 3, 14, 977, 8, 14, 1, 14, 5, 14, 980, 8, 14, 10, 14, 12, 14, 983, 9, 14, + 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, 994, + 8, 15, 1, 15, 3, 15, 997, 8, 15, 1, 15, 1, 15, 3, 15, 1001, 8, 15, 1, 15, + 3, 15, 1004, 8, 15, 1, 15, 1, 15, 3, 15, 1008, 8, 15, 1, 15, 3, 15, 1011, + 8, 15, 1, 15, 1, 15, 3, 15, 1015, 8, 15, 1, 15, 3, 15, 1018, 8, 15, 1, + 15, 3, 15, 1021, 8, 15, 1, 15, 1, 15, 3, 15, 1025, 8, 15, 1, 15, 3, 15, + 1028, 8, 15, 1, 15, 1, 15, 3, 15, 1032, 8, 15, 1, 15, 1, 15, 1, 16, 1, + 16, 3, 16, 1038, 8, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 1044, 8, 16, + 1, 16, 1, 16, 5, 16, 1048, 8, 16, 10, 16, 12, 16, 1051, 9, 16, 1, 16, 1, + 16, 5, 16, 1055, 8, 16, 10, 16, 12, 16, 1058, 9, 16, 1, 16, 1, 16, 1, 17, + 1, 17, 3, 17, 1064, 8, 17, 1, 17, 3, 17, 1067, 8, 17, 1, 17, 1, 17, 3, + 17, 1071, 8, 17, 1, 17, 1, 17, 1, 17, 3, 17, 1076, 8, 17, 1, 17, 1, 17, + 5, 17, 1080, 8, 17, 10, 17, 12, 17, 1083, 9, 17, 1, 17, 1, 17, 1, 17, 1, + 17, 5, 17, 1089, 8, 17, 10, 17, 12, 17, 1092, 9, 17, 1, 17, 1, 17, 3, 17, + 1096, 8, 17, 1, 18, 1, 18, 1, 18, 3, 18, 1101, 8, 18, 1, 18, 1, 18, 1, + 18, 5, 18, 1106, 8, 18, 10, 18, 12, 18, 1109, 9, 18, 1, 19, 1, 19, 1, 19, + 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 5, 19, 1123, + 8, 19, 10, 19, 12, 19, 1126, 9, 19, 1, 19, 1, 19, 1, 20, 1, 20, 3, 20, + 1132, 8, 20, 1, 20, 1, 20, 3, 20, 1136, 8, 20, 1, 20, 1, 20, 1, 20, 1, + 20, 1, 20, 1, 20, 1, 20, 1, 20, 3, 20, 1146, 8, 20, 1, 20, 1, 20, 3, 20, + 1150, 8, 20, 1, 20, 1, 20, 3, 20, 1154, 8, 20, 1, 20, 1, 20, 3, 20, 1158, + 8, 20, 1, 20, 1, 20, 3, 20, 1162, 8, 20, 1, 20, 5, 20, 1165, 8, 20, 10, + 20, 12, 20, 1168, 9, 20, 3, 20, 1170, 8, 20, 1, 20, 3, 20, 1173, 8, 20, + 1, 20, 3, 20, 1176, 8, 20, 1, 20, 3, 20, 1179, 8, 20, 1, 20, 1, 20, 1, + 20, 1, 20, 3, 20, 1185, 8, 20, 1, 20, 1, 20, 3, 20, 1189, 8, 20, 1, 20, + 1, 20, 1, 20, 1, 20, 3, 20, 1195, 8, 20, 1, 20, 5, 20, 1198, 8, 20, 10, + 20, 12, 20, 1201, 9, 20, 3, 20, 1203, 8, 20, 1, 20, 3, 20, 1206, 8, 20, + 3, 20, 1208, 8, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, + 21, 1, 21, 3, 21, 1219, 8, 21, 1, 21, 1, 21, 3, 21, 1223, 8, 21, 1, 21, + 3, 21, 1226, 8, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, + 22, 1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 1240, 8, 22, 1, 22, 3, 22, 1243, + 8, 22, 1, 22, 1, 22, 3, 22, 1247, 8, 22, 1, 22, 3, 22, 1250, 8, 22, 1, + 22, 1, 22, 3, 22, 1254, 8, 22, 1, 22, 3, 22, 1257, 8, 22, 1, 22, 1, 22, + 3, 22, 1261, 8, 22, 1, 22, 3, 22, 1264, 8, 22, 1, 22, 1, 22, 3, 22, 1268, + 8, 22, 1, 22, 3, 22, 1271, 8, 22, 1, 22, 3, 22, 1274, 8, 22, 1, 22, 1, + 22, 3, 22, 1278, 8, 22, 1, 22, 3, 22, 1281, 8, 22, 1, 22, 1, 22, 3, 22, + 1285, 8, 22, 1, 22, 1, 22, 1, 23, 1, 23, 3, 23, 1291, 8, 23, 1, 23, 1, + 23, 3, 23, 1295, 8, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, + 1, 23, 1, 23, 1, 23, 3, 23, 1307, 8, 23, 1, 23, 1, 23, 1, 24, 1, 24, 3, + 24, 1313, 8, 24, 1, 24, 1, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 5, 25, + 1322, 8, 25, 10, 25, 12, 25, 1325, 9, 25, 1, 25, 1, 25, 3, 25, 1329, 8, + 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 3, 25, 1337, 8, 25, 1, 26, + 1, 26, 1, 27, 1, 27, 1, 28, 1, 28, 3, 28, 1345, 8, 28, 1, 28, 1, 28, 1, + 28, 3, 28, 1350, 8, 28, 1, 28, 3, 28, 1353, 8, 28, 1, 28, 1, 28, 1, 28, + 3, 28, 1358, 8, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 3, 28, 1366, + 8, 28, 1, 28, 1, 28, 1, 28, 3, 28, 1371, 8, 28, 1, 28, 1, 28, 1, 28, 1, + 28, 3, 28, 1377, 8, 28, 1, 28, 1, 28, 1, 28, 3, 28, 1382, 8, 28, 1, 28, + 1, 28, 3, 28, 1386, 8, 28, 3, 28, 1388, 8, 28, 1, 29, 3, 29, 1391, 8, 29, + 1, 29, 1, 29, 3, 29, 1395, 8, 29, 1, 29, 1, 29, 3, 29, 1399, 8, 29, 1, + 29, 3, 29, 1402, 8, 29, 1, 29, 1, 29, 3, 29, 1406, 8, 29, 1, 29, 1, 29, + 3, 29, 1410, 8, 29, 1, 29, 1, 29, 3, 29, 1414, 8, 29, 1, 29, 1, 29, 1, + 29, 1, 29, 3, 29, 1420, 8, 29, 1, 29, 3, 29, 1423, 8, 29, 1, 30, 1, 30, + 1, 30, 1, 30, 1, 30, 3, 30, 1430, 8, 30, 1, 31, 1, 31, 1, 31, 3, 31, 1435, + 8, 31, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 1441, 8, 32, 1, 33, 1, 33, 1, + 33, 5, 33, 1446, 8, 33, 10, 33, 12, 33, 1449, 9, 33, 1, 33, 1, 33, 1, 33, + 3, 33, 1454, 8, 33, 1, 33, 1, 33, 1, 33, 1, 33, 5, 33, 1460, 8, 33, 10, + 33, 12, 33, 1463, 9, 33, 3, 33, 1465, 8, 33, 1, 33, 1, 33, 1, 33, 5, 33, + 1470, 8, 33, 10, 33, 12, 33, 1473, 9, 33, 3, 33, 1475, 8, 33, 3, 33, 1477, + 8, 33, 1, 34, 1, 34, 1, 34, 1, 34, 3, 34, 1483, 8, 34, 1, 35, 1, 35, 1, + 35, 1, 35, 3, 35, 1489, 8, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 36, + 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 3, 36, 1506, + 8, 36, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 3, 37, 1513, 8, 37, 1, 38, 1, + 38, 1, 38, 1, 39, 1, 39, 3, 39, 1520, 8, 39, 1, 39, 1, 39, 1, 39, 1, 39, + 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 3, 39, 1532, 8, 39, 1, 39, 1, + 39, 1, 39, 3, 39, 1537, 8, 39, 1, 39, 3, 39, 1540, 8, 39, 1, 40, 3, 40, + 1543, 8, 40, 1, 40, 1, 40, 1, 40, 1, 41, 1, 41, 1, 41, 1, 42, 1, 42, 1, + 42, 1, 42, 1, 42, 3, 42, 1556, 8, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, + 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 3, 42, 1569, 8, 42, 1, 42, 1, + 42, 1, 42, 3, 42, 1574, 8, 42, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, + 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 3, 43, 1590, 8, + 43, 1, 44, 1, 44, 1, 44, 1, 44, 5, 44, 1596, 8, 44, 10, 44, 12, 44, 1599, + 9, 44, 1, 44, 1, 44, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 3, 45, 1608, 8, + 45, 1, 45, 3, 45, 1611, 8, 45, 1, 45, 3, 45, 1614, 8, 45, 1, 46, 1, 46, + 5, 46, 1618, 8, 46, 10, 46, 12, 46, 1621, 9, 46, 1, 46, 3, 46, 1624, 8, + 46, 1, 46, 3, 46, 1627, 8, 46, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, + 1, 47, 1, 47, 1, 47, 3, 47, 1638, 8, 47, 1, 47, 3, 47, 1641, 8, 47, 1, + 47, 1, 47, 1, 47, 3, 47, 1646, 8, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, + 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 3, 47, 1659, 8, 47, 1, 47, 1, + 47, 1, 47, 1, 47, 1, 47, 3, 47, 1666, 8, 47, 1, 47, 1, 47, 1, 47, 1, 47, + 1, 47, 3, 47, 1673, 8, 47, 3, 47, 1675, 8, 47, 1, 47, 1, 47, 1, 47, 1, + 47, 1, 47, 3, 47, 1682, 8, 47, 1, 48, 1, 48, 3, 48, 1686, 8, 48, 3, 48, + 1688, 8, 48, 1, 48, 1, 48, 1, 48, 3, 48, 1693, 8, 48, 1, 48, 3, 48, 1696, + 8, 48, 1, 48, 1, 48, 5, 48, 1700, 8, 48, 10, 48, 12, 48, 1703, 9, 48, 1, + 48, 1, 48, 3, 48, 1707, 8, 48, 3, 48, 1709, 8, 48, 1, 48, 1, 48, 3, 48, + 1713, 8, 48, 1, 48, 3, 48, 1716, 8, 48, 1, 48, 3, 48, 1719, 8, 48, 1, 48, + 1, 48, 5, 48, 1723, 8, 48, 10, 48, 12, 48, 1726, 9, 48, 1, 48, 1, 48, 3, + 48, 1730, 8, 48, 3, 48, 1732, 8, 48, 1, 48, 1, 48, 1, 48, 3, 48, 1737, + 8, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 3, 48, 1744, 8, 48, 3, 48, 1746, + 8, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 3, 48, 1753, 8, 48, 1, 49, 1, + 49, 1, 49, 3, 49, 1758, 8, 49, 1, 49, 1, 49, 3, 49, 1762, 8, 49, 1, 49, + 3, 49, 1765, 8, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 3, 50, 1773, + 8, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 3, 50, 1781, 8, 50, 3, + 50, 1783, 8, 50, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, + 3, 51, 1793, 8, 51, 1, 52, 1, 52, 3, 52, 1797, 8, 52, 1, 52, 3, 52, 1800, + 8, 52, 1, 52, 1, 52, 5, 52, 1804, 8, 52, 10, 52, 12, 52, 1807, 9, 52, 1, + 52, 1, 52, 3, 52, 1811, 8, 52, 1, 52, 3, 52, 1814, 8, 52, 1, 52, 1, 52, + 5, 52, 1818, 8, 52, 10, 52, 12, 52, 1821, 9, 52, 3, 52, 1823, 8, 52, 1, + 53, 1, 53, 3, 53, 1827, 8, 53, 1, 53, 3, 53, 1830, 8, 53, 1, 53, 1, 53, + 3, 53, 1834, 8, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1839, 8, 53, 1, 53, 1, + 53, 1, 53, 3, 53, 1844, 8, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1849, 8, 53, + 1, 53, 1, 53, 3, 53, 1853, 8, 53, 1, 53, 1, 53, 3, 53, 1857, 8, 53, 1, + 53, 1, 53, 3, 53, 1861, 8, 53, 1, 53, 1, 53, 3, 53, 1865, 8, 53, 1, 53, + 1, 53, 3, 53, 1869, 8, 53, 1, 53, 1, 53, 3, 53, 1873, 8, 53, 1, 53, 1, + 53, 1, 53, 3, 53, 1878, 8, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1883, 8, 53, + 1, 53, 1, 53, 1, 53, 3, 53, 1888, 8, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, + 53, 1894, 8, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1899, 8, 53, 1, 53, 1, 53, + 1, 53, 3, 53, 1904, 8, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1909, 8, 53, 1, + 53, 1, 53, 1, 53, 3, 53, 1914, 8, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1919, + 8, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1925, 8, 53, 1, 53, 1, 53, 1, + 53, 3, 53, 1930, 8, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1935, 8, 53, 1, 53, + 1, 53, 1, 53, 3, 53, 1940, 8, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1945, 8, + 53, 1, 53, 1, 53, 1, 53, 3, 53, 1950, 8, 53, 1, 53, 1, 53, 1, 53, 3, 53, + 1955, 8, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1960, 8, 53, 1, 53, 1, 53, 1, + 53, 1, 53, 1, 53, 3, 53, 1967, 8, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1972, + 8, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1977, 8, 53, 1, 53, 1, 53, 1, 53, 3, + 53, 1982, 8, 53, 1, 53, 1, 53, 3, 53, 1986, 8, 53, 1, 53, 1, 53, 1, 53, + 3, 53, 1991, 8, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1999, + 8, 53, 1, 53, 1, 53, 1, 53, 3, 53, 2004, 8, 53, 1, 53, 1, 53, 1, 53, 1, + 53, 3, 53, 2010, 8, 53, 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 56, 1, 56, + 1, 56, 1, 56, 1, 56, 3, 56, 2022, 8, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, + 56, 3, 56, 2029, 8, 56, 3, 56, 2031, 8, 56, 1, 56, 1, 56, 1, 56, 1, 56, + 5, 56, 2037, 8, 56, 10, 56, 12, 56, 2040, 9, 56, 1, 56, 1, 56, 3, 56, 2044, + 8, 56, 1, 57, 3, 57, 2047, 8, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, + 57, 3, 57, 2055, 8, 57, 1, 57, 1, 57, 1, 57, 1, 57, 3, 57, 2061, 8, 57, + 1, 57, 1, 57, 3, 57, 2065, 8, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, + 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 3, 57, 2078, 8, 57, 1, 57, 1, 57, + 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 3, 57, 2090, 8, + 57, 3, 57, 2092, 8, 57, 1, 58, 3, 58, 2095, 8, 58, 1, 58, 1, 58, 1, 58, + 1, 58, 1, 58, 1, 58, 3, 58, 2103, 8, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, + 58, 2109, 8, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 2115, 8, 58, 1, 59, + 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 5, 59, 2126, 8, + 59, 10, 59, 12, 59, 2129, 9, 59, 1, 59, 1, 59, 5, 59, 2133, 8, 59, 10, + 59, 12, 59, 2136, 9, 59, 1, 59, 1, 59, 1, 59, 1, 59, 5, 59, 2142, 8, 59, + 10, 59, 12, 59, 2145, 9, 59, 1, 59, 1, 59, 3, 59, 2149, 8, 59, 1, 59, 1, + 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 5, 59, 2158, 8, 59, 10, 59, 12, + 59, 2161, 9, 59, 1, 59, 1, 59, 1, 59, 1, 59, 5, 59, 2167, 8, 59, 10, 59, + 12, 59, 2170, 9, 59, 1, 59, 1, 59, 3, 59, 2174, 8, 59, 1, 59, 1, 59, 1, + 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 5, 59, 2184, 8, 59, 10, 59, 12, + 59, 2187, 9, 59, 1, 59, 1, 59, 5, 59, 2191, 8, 59, 10, 59, 12, 59, 2194, + 9, 59, 1, 59, 1, 59, 1, 59, 1, 59, 5, 59, 2200, 8, 59, 10, 59, 12, 59, + 2203, 9, 59, 1, 59, 1, 59, 3, 59, 2207, 8, 59, 1, 59, 1, 59, 1, 59, 1, + 59, 1, 59, 1, 59, 1, 59, 1, 59, 5, 59, 2217, 8, 59, 10, 59, 12, 59, 2220, + 9, 59, 1, 59, 1, 59, 5, 59, 2224, 8, 59, 10, 59, 12, 59, 2227, 9, 59, 1, + 59, 1, 59, 1, 59, 1, 59, 5, 59, 2233, 8, 59, 10, 59, 12, 59, 2236, 9, 59, + 1, 59, 1, 59, 3, 59, 2240, 8, 59, 1, 59, 1, 59, 1, 59, 5, 59, 2245, 8, + 59, 10, 59, 12, 59, 2248, 9, 59, 1, 59, 1, 59, 1, 59, 1, 59, 5, 59, 2254, + 8, 59, 10, 59, 12, 59, 2257, 9, 59, 1, 59, 1, 59, 3, 59, 2261, 8, 59, 3, + 59, 2263, 8, 59, 1, 60, 1, 60, 1, 60, 3, 60, 2268, 8, 60, 1, 61, 1, 61, + 1, 61, 1, 61, 4, 61, 2274, 8, 61, 11, 61, 12, 61, 2275, 1, 61, 1, 61, 1, + 62, 1, 62, 1, 62, 5, 62, 2283, 8, 62, 10, 62, 12, 62, 2286, 9, 62, 1, 63, + 3, 63, 2289, 8, 63, 1, 63, 3, 63, 2292, 8, 63, 1, 63, 1, 63, 3, 63, 2296, + 8, 63, 1, 63, 1, 63, 1, 63, 3, 63, 2301, 8, 63, 1, 63, 1, 63, 1, 63, 1, + 63, 3, 63, 2307, 8, 63, 1, 63, 1, 63, 1, 63, 1, 63, 3, 63, 2313, 8, 63, + 1, 63, 1, 63, 1, 63, 3, 63, 2318, 8, 63, 1, 63, 1, 63, 1, 63, 3, 63, 2323, + 8, 63, 1, 63, 1, 63, 1, 63, 3, 63, 2328, 8, 63, 1, 63, 1, 63, 1, 63, 3, + 63, 2333, 8, 63, 1, 63, 3, 63, 2336, 8, 63, 1, 64, 1, 64, 1, 64, 3, 64, + 2341, 8, 64, 1, 64, 4, 64, 2344, 8, 64, 11, 64, 12, 64, 2345, 1, 64, 1, + 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 3, 64, 2356, 8, 64, 1, 65, + 1, 65, 3, 65, 2360, 8, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 2367, + 8, 65, 1, 65, 1, 65, 1, 65, 3, 65, 2372, 8, 65, 1, 65, 3, 65, 2375, 8, + 65, 1, 65, 1, 65, 1, 65, 3, 65, 2380, 8, 65, 1, 65, 3, 65, 2383, 8, 65, + 1, 65, 1, 65, 3, 65, 2387, 8, 65, 1, 65, 1, 65, 3, 65, 2391, 8, 65, 1, + 66, 1, 66, 1, 66, 1, 66, 5, 66, 2397, 8, 66, 10, 66, 12, 66, 2400, 9, 66, + 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 68, 1, 68, 1, 68, 1, + 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 3, 68, 2418, 8, 68, 1, 68, 3, 68, + 2421, 8, 68, 1, 68, 3, 68, 2424, 8, 68, 1, 68, 1, 68, 3, 68, 2428, 8, 68, + 1, 68, 1, 68, 1, 69, 1, 69, 1, 69, 1, 69, 5, 69, 2436, 8, 69, 10, 69, 12, + 69, 2439, 9, 69, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, + 5, 70, 2449, 8, 70, 10, 70, 12, 70, 2452, 9, 70, 1, 70, 1, 70, 1, 71, 1, + 71, 3, 71, 2458, 8, 71, 1, 71, 3, 71, 2461, 8, 71, 1, 71, 1, 71, 1, 71, + 3, 71, 2466, 8, 71, 1, 71, 1, 71, 1, 71, 5, 71, 2471, 8, 71, 10, 71, 12, + 71, 2474, 9, 71, 3, 71, 2476, 8, 71, 1, 71, 3, 71, 2479, 8, 71, 1, 72, + 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 3, 72, 2490, 8, + 72, 1, 72, 3, 72, 2493, 8, 72, 1, 72, 1, 72, 3, 72, 2497, 8, 72, 1, 72, + 1, 72, 1, 73, 1, 73, 1, 73, 1, 73, 3, 73, 2505, 8, 73, 1, 73, 3, 73, 2508, + 8, 73, 1, 73, 1, 73, 1, 73, 3, 73, 2513, 8, 73, 1, 73, 1, 73, 1, 73, 1, + 73, 1, 73, 1, 73, 3, 73, 2521, 8, 73, 1, 73, 1, 73, 1, 73, 1, 73, 3, 73, + 2527, 8, 73, 1, 73, 1, 73, 3, 73, 2531, 8, 73, 1, 74, 1, 74, 3, 74, 2535, + 8, 74, 1, 74, 5, 74, 2538, 8, 74, 10, 74, 12, 74, 2541, 9, 74, 1, 74, 1, + 74, 3, 74, 2545, 8, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 3, 74, 2552, + 8, 74, 1, 74, 1, 74, 3, 74, 2556, 8, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, + 74, 1, 74, 1, 74, 5, 74, 2565, 8, 74, 10, 74, 12, 74, 2568, 9, 74, 1, 74, + 1, 74, 1, 74, 1, 74, 1, 74, 3, 74, 2575, 8, 74, 1, 74, 3, 74, 2578, 8, + 74, 1, 74, 1, 74, 5, 74, 2582, 8, 74, 10, 74, 12, 74, 2585, 9, 74, 1, 74, + 1, 74, 1, 74, 3, 74, 2590, 8, 74, 3, 74, 2592, 8, 74, 1, 74, 1, 74, 1, + 74, 3, 74, 2597, 8, 74, 1, 74, 3, 74, 2600, 8, 74, 1, 74, 1, 74, 5, 74, + 2604, 8, 74, 10, 74, 12, 74, 2607, 9, 74, 1, 74, 1, 74, 1, 74, 3, 74, 2612, + 8, 74, 3, 74, 2614, 8, 74, 1, 74, 1, 74, 3, 74, 2618, 8, 74, 1, 74, 3, + 74, 2621, 8, 74, 1, 74, 3, 74, 2624, 8, 74, 1, 74, 1, 74, 5, 74, 2628, + 8, 74, 10, 74, 12, 74, 2631, 9, 74, 1, 74, 1, 74, 1, 74, 3, 74, 2636, 8, + 74, 1, 74, 3, 74, 2639, 8, 74, 1, 74, 1, 74, 5, 74, 2643, 8, 74, 10, 74, + 12, 74, 2646, 9, 74, 1, 74, 1, 74, 1, 74, 3, 74, 2651, 8, 74, 3, 74, 2653, + 8, 74, 1, 74, 1, 74, 1, 74, 3, 74, 2658, 8, 74, 1, 74, 1, 74, 1, 74, 1, + 74, 1, 74, 1, 74, 3, 74, 2666, 8, 74, 3, 74, 2668, 8, 74, 1, 74, 1, 74, + 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 3, 74, 2677, 8, 74, 1, 74, 3, 74, 2680, + 8, 74, 1, 74, 3, 74, 2683, 8, 74, 1, 74, 1, 74, 1, 74, 3, 74, 2688, 8, + 74, 3, 74, 2690, 8, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, + 3, 74, 2699, 8, 74, 1, 74, 3, 74, 2702, 8, 74, 1, 74, 3, 74, 2705, 8, 74, + 1, 74, 1, 74, 1, 74, 3, 74, 2710, 8, 74, 3, 74, 2712, 8, 74, 1, 74, 1, + 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 3, 74, 2721, 8, 74, 1, 74, 1, 74, + 1, 74, 3, 74, 2726, 8, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 3, + 74, 2734, 8, 74, 1, 74, 1, 74, 3, 74, 2738, 8, 74, 1, 74, 1, 74, 1, 74, + 1, 74, 1, 74, 1, 74, 3, 74, 2746, 8, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, + 74, 1, 74, 1, 74, 1, 74, 3, 74, 2756, 8, 74, 1, 74, 1, 74, 1, 74, 3, 74, + 2761, 8, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 3, 74, 2768, 8, 74, 1, + 74, 1, 74, 3, 74, 2772, 8, 74, 1, 74, 1, 74, 3, 74, 2776, 8, 74, 1, 74, + 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, + 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 3, 74, 2795, 8, 74, 1, 74, 1, 74, + 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 3, 74, 2805, 8, 74, 1, 74, 1, + 74, 1, 74, 1, 74, 3, 74, 2811, 8, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, + 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 3, + 74, 2828, 8, 74, 1, 74, 1, 74, 3, 74, 2832, 8, 74, 1, 74, 1, 74, 1, 74, + 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 3, 74, 2842, 8, 74, 1, 74, 1, 74, 1, + 74, 3, 74, 2847, 8, 74, 1, 74, 3, 74, 2850, 8, 74, 1, 74, 1, 74, 1, 74, + 1, 74, 1, 74, 1, 74, 1, 74, 3, 74, 2859, 8, 74, 1, 74, 1, 74, 1, 74, 1, + 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 3, 74, 2870, 8, 74, 1, 74, 1, 74, + 1, 74, 1, 74, 5, 74, 2876, 8, 74, 10, 74, 12, 74, 2879, 9, 74, 1, 74, 1, + 74, 1, 74, 3, 74, 2884, 8, 74, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, + 5, 75, 2892, 8, 75, 10, 75, 12, 75, 2895, 9, 75, 1, 75, 1, 75, 1, 75, 1, + 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 2906, 8, 75, 1, 75, 1, 75, + 1, 75, 1, 75, 1, 75, 3, 75, 2913, 8, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, + 75, 3, 75, 2920, 8, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, + 1, 75, 1, 75, 1, 75, 1, 75, 5, 75, 2933, 8, 75, 10, 75, 12, 75, 2936, 9, + 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, + 3, 75, 2948, 8, 75, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 2954, 8, 75, 1, + 75, 1, 75, 1, 75, 1, 75, 3, 75, 2960, 8, 75, 1, 75, 1, 75, 1, 75, 1, 75, + 3, 75, 2966, 8, 75, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 2972, 8, 75, 1, + 75, 1, 75, 1, 75, 1, 75, 3, 75, 2978, 8, 75, 1, 75, 1, 75, 1, 75, 1, 75, + 3, 75, 2984, 8, 75, 1, 76, 1, 76, 1, 76, 3, 76, 2989, 8, 76, 1, 76, 1, + 76, 1, 77, 1, 77, 1, 77, 3, 77, 2996, 8, 77, 1, 77, 1, 77, 1, 78, 1, 78, + 1, 78, 3, 78, 3003, 8, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 3, 78, 3010, + 8, 78, 1, 78, 1, 78, 1, 78, 3, 78, 3015, 8, 78, 1, 78, 5, 78, 3018, 8, + 78, 10, 78, 12, 78, 3021, 9, 78, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, + 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 3, 80, 3034, 8, 80, 1, 80, 1, 80, + 1, 81, 1, 81, 1, 81, 3, 81, 3041, 8, 81, 1, 81, 1, 81, 1, 82, 1, 82, 1, + 82, 3, 82, 3048, 8, 82, 1, 82, 1, 82, 1, 83, 1, 83, 3, 83, 3054, 8, 83, + 1, 83, 1, 83, 3, 83, 3058, 8, 83, 1, 83, 1, 83, 3, 83, 3062, 8, 83, 1, + 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 3069, 8, 84, 1, 84, 3, 84, 3072, + 8, 84, 1, 85, 1, 85, 1, 85, 3, 85, 3077, 8, 85, 1, 85, 1, 85, 1, 86, 1, + 86, 1, 86, 3, 86, 3084, 8, 86, 1, 86, 1, 86, 1, 86, 5, 86, 3089, 8, 86, + 10, 86, 12, 86, 3092, 9, 86, 1, 86, 3, 86, 3095, 8, 86, 1, 87, 1, 87, 1, + 87, 3, 87, 3100, 8, 87, 1, 87, 1, 87, 1, 87, 5, 87, 3105, 8, 87, 10, 87, + 12, 87, 3108, 9, 87, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, + 88, 5, 88, 3118, 8, 88, 10, 88, 12, 88, 3121, 9, 88, 3, 88, 3123, 8, 88, + 1, 88, 1, 88, 1, 88, 3, 88, 3128, 8, 88, 1, 88, 1, 88, 1, 88, 3, 88, 3133, + 8, 88, 5, 88, 3135, 8, 88, 10, 88, 12, 88, 3138, 9, 88, 1, 88, 1, 88, 1, + 88, 3, 88, 3143, 8, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 5, 89, 3150, + 8, 89, 10, 89, 12, 89, 3153, 9, 89, 1, 90, 1, 90, 1, 90, 1, 90, 1, 91, + 1, 91, 3, 91, 3161, 8, 91, 1, 91, 1, 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, + 92, 3, 92, 3170, 8, 92, 1, 92, 3, 92, 3173, 8, 92, 1, 93, 1, 93, 3, 93, + 3177, 8, 93, 1, 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 1, 95, 3, 95, 3186, + 8, 95, 1, 96, 1, 96, 3, 96, 3190, 8, 96, 1, 96, 3, 96, 3193, 8, 96, 1, + 96, 3, 96, 3196, 8, 96, 1, 96, 1, 96, 1, 96, 1, 96, 3, 96, 3202, 8, 96, + 1, 96, 3, 96, 3205, 8, 96, 1, 96, 1, 96, 3, 96, 3209, 8, 96, 1, 96, 3, + 96, 3212, 8, 96, 1, 96, 1, 96, 3, 96, 3216, 8, 96, 1, 96, 3, 96, 3219, + 8, 96, 1, 96, 1, 96, 1, 96, 1, 96, 5, 96, 3225, 8, 96, 10, 96, 12, 96, + 3228, 9, 96, 3, 96, 3230, 8, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, + 96, 1, 96, 5, 96, 3239, 8, 96, 10, 96, 12, 96, 3242, 9, 96, 3, 96, 3244, + 8, 96, 1, 97, 1, 97, 1, 97, 3, 97, 3249, 8, 97, 1, 97, 3, 97, 3252, 8, + 97, 1, 97, 1, 97, 1, 97, 3, 97, 3257, 8, 97, 1, 97, 1, 97, 1, 97, 1, 97, + 1, 97, 1, 97, 1, 97, 1, 97, 3, 97, 3267, 8, 97, 1, 97, 1, 97, 1, 97, 3, + 97, 3272, 8, 97, 1, 97, 1, 97, 4, 97, 3276, 8, 97, 11, 97, 12, 97, 3277, + 3, 97, 3280, 8, 97, 1, 97, 1, 97, 4, 97, 3284, 8, 97, 11, 97, 12, 97, 3285, + 3, 97, 3288, 8, 97, 1, 97, 1, 97, 1, 97, 1, 97, 3, 97, 3294, 8, 97, 1, + 97, 1, 97, 1, 97, 1, 97, 5, 97, 3300, 8, 97, 10, 97, 12, 97, 3303, 9, 97, + 1, 97, 1, 97, 3, 97, 3307, 8, 97, 1, 97, 1, 97, 1, 97, 1, 97, 5, 97, 3313, + 8, 97, 10, 97, 12, 97, 3316, 9, 97, 3, 97, 3318, 8, 97, 1, 98, 1, 98, 1, + 98, 3, 98, 3323, 8, 98, 1, 98, 3, 98, 3326, 8, 98, 1, 98, 1, 98, 1, 98, + 3, 98, 3331, 8, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 3, 98, 3339, + 8, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 3, 98, 3347, 8, 98, 1, + 98, 1, 98, 1, 98, 1, 98, 3, 98, 3353, 8, 98, 1, 98, 1, 98, 1, 98, 1, 98, + 5, 98, 3359, 8, 98, 10, 98, 12, 98, 3362, 9, 98, 1, 98, 1, 98, 3, 98, 3366, + 8, 98, 1, 98, 1, 98, 1, 98, 1, 98, 5, 98, 3372, 8, 98, 10, 98, 12, 98, + 3375, 9, 98, 3, 98, 3377, 8, 98, 1, 99, 1, 99, 3, 99, 3381, 8, 99, 1, 99, + 3, 99, 3384, 8, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 3, 99, 3392, + 8, 99, 1, 99, 1, 99, 1, 99, 1, 99, 3, 99, 3398, 8, 99, 1, 99, 1, 99, 1, + 99, 1, 99, 1, 99, 5, 99, 3405, 8, 99, 10, 99, 12, 99, 3408, 9, 99, 3, 99, + 3410, 8, 99, 1, 100, 1, 100, 3, 100, 3414, 8, 100, 1, 100, 1, 100, 3, 100, + 3418, 8, 100, 1, 100, 1, 100, 3, 100, 3422, 8, 100, 1, 100, 4, 100, 3425, + 8, 100, 11, 100, 12, 100, 3426, 1, 100, 1, 100, 3, 100, 3431, 8, 100, 1, + 100, 1, 100, 3, 100, 3435, 8, 100, 3, 100, 3437, 8, 100, 1, 100, 3, 100, + 3440, 8, 100, 1, 100, 3, 100, 3443, 8, 100, 1, 100, 3, 100, 3446, 8, 100, + 1, 100, 1, 100, 4, 100, 3450, 8, 100, 11, 100, 12, 100, 3451, 1, 100, 1, + 100, 3, 100, 3456, 8, 100, 1, 100, 3, 100, 3459, 8, 100, 1, 100, 3, 100, + 3462, 8, 100, 1, 100, 3, 100, 3465, 8, 100, 1, 100, 3, 100, 3468, 8, 100, + 1, 100, 1, 100, 1, 100, 4, 100, 3473, 8, 100, 11, 100, 12, 100, 3474, 3, + 100, 3477, 8, 100, 1, 101, 1, 101, 3, 101, 3481, 8, 101, 1, 102, 1, 102, + 1, 102, 3, 102, 3486, 8, 102, 1, 102, 1, 102, 1, 102, 1, 102, 3, 102, 3492, + 8, 102, 1, 102, 5, 102, 3495, 8, 102, 10, 102, 12, 102, 3498, 9, 102, 1, + 103, 1, 103, 1, 103, 1, 103, 3, 103, 3504, 8, 103, 1, 103, 1, 103, 1, 103, + 1, 103, 3, 103, 3510, 8, 103, 1, 103, 5, 103, 3513, 8, 103, 10, 103, 12, + 103, 3516, 9, 103, 3, 103, 3518, 8, 103, 1, 104, 1, 104, 1, 104, 1, 104, + 3, 104, 3524, 8, 104, 1, 105, 1, 105, 3, 105, 3528, 8, 105, 1, 106, 1, + 106, 1, 106, 1, 106, 1, 106, 1, 106, 3, 106, 3536, 8, 106, 1, 107, 1, 107, + 3, 107, 3540, 8, 107, 1, 107, 3, 107, 3543, 8, 107, 1, 107, 3, 107, 3546, + 8, 107, 1, 107, 1, 107, 1, 107, 3, 107, 3551, 8, 107, 1, 107, 3, 107, 3554, + 8, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 3, 107, 3561, 8, 107, 1, + 107, 1, 107, 3, 107, 3565, 8, 107, 1, 107, 3, 107, 3568, 8, 107, 1, 107, + 1, 107, 3, 107, 3572, 8, 107, 1, 108, 1, 108, 3, 108, 3576, 8, 108, 1, + 108, 3, 108, 3579, 8, 108, 1, 108, 3, 108, 3582, 8, 108, 1, 108, 1, 108, + 1, 108, 3, 108, 3587, 8, 108, 1, 108, 1, 108, 1, 108, 1, 108, 3, 108, 3593, + 8, 108, 5, 108, 3595, 8, 108, 10, 108, 12, 108, 3598, 9, 108, 1, 108, 1, + 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 3, 108, 3607, 8, 108, 1, 108, + 1, 108, 1, 108, 1, 108, 3, 108, 3613, 8, 108, 5, 108, 3615, 8, 108, 10, + 108, 12, 108, 3618, 9, 108, 1, 108, 1, 108, 1, 108, 3, 108, 3623, 8, 108, + 1, 108, 1, 108, 3, 108, 3627, 8, 108, 1, 109, 1, 109, 1, 109, 1, 109, 3, + 109, 3633, 8, 109, 1, 109, 3, 109, 3636, 8, 109, 1, 110, 1, 110, 1, 110, + 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 3, 110, 3648, 8, + 110, 1, 110, 1, 110, 3, 110, 3652, 8, 110, 1, 110, 1, 110, 3, 110, 3656, + 8, 110, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 3, 111, 3664, 8, + 111, 1, 111, 1, 111, 3, 111, 3668, 8, 111, 1, 112, 1, 112, 1, 112, 1, 112, + 1, 113, 1, 113, 3, 113, 3676, 8, 113, 1, 113, 3, 113, 3679, 8, 113, 1, + 113, 1, 113, 3, 113, 3683, 8, 113, 1, 113, 3, 113, 3686, 8, 113, 1, 113, + 1, 113, 1, 113, 1, 113, 5, 113, 3692, 8, 113, 10, 113, 12, 113, 3695, 9, + 113, 1, 113, 1, 113, 3, 113, 3699, 8, 113, 1, 113, 3, 113, 3702, 8, 113, + 1, 113, 3, 113, 3705, 8, 113, 1, 114, 1, 114, 3, 114, 3709, 8, 114, 1, + 114, 3, 114, 3712, 8, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 5, 114, + 3719, 8, 114, 10, 114, 12, 114, 3722, 9, 114, 1, 114, 1, 114, 3, 114, 3726, + 8, 114, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 5, 115, 3733, 8, 115, 10, + 115, 12, 115, 3736, 9, 115, 1, 116, 1, 116, 3, 116, 3740, 8, 116, 1, 117, + 1, 117, 1, 117, 5, 117, 3745, 8, 117, 10, 117, 12, 117, 3748, 9, 117, 1, + 118, 1, 118, 5, 118, 3752, 8, 118, 10, 118, 12, 118, 3755, 9, 118, 1, 118, + 1, 118, 1, 118, 5, 118, 3760, 8, 118, 10, 118, 12, 118, 3763, 9, 118, 1, + 118, 1, 118, 1, 118, 3, 118, 3768, 8, 118, 1, 119, 1, 119, 1, 119, 1, 119, + 1, 119, 1, 119, 3, 119, 3776, 8, 119, 1, 119, 3, 119, 3779, 8, 119, 1, + 119, 3, 119, 3782, 8, 119, 1, 119, 1, 119, 1, 119, 5, 119, 3787, 8, 119, + 10, 119, 12, 119, 3790, 9, 119, 3, 119, 3792, 8, 119, 1, 119, 1, 119, 1, + 119, 1, 119, 1, 119, 3, 119, 3799, 8, 119, 1, 119, 3, 119, 3802, 8, 119, + 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 3, 119, 3810, 8, 119, 1, + 120, 1, 120, 1, 120, 1, 120, 3, 120, 3816, 8, 120, 1, 120, 1, 120, 1, 120, + 1, 120, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 3, 121, 3827, 8, 121, 1, + 122, 3, 122, 3830, 8, 122, 1, 122, 1, 122, 3, 122, 3834, 8, 122, 1, 122, + 1, 122, 5, 122, 3838, 8, 122, 10, 122, 12, 122, 3841, 9, 122, 1, 122, 1, + 122, 1, 122, 1, 122, 5, 122, 3847, 8, 122, 10, 122, 12, 122, 3850, 9, 122, + 1, 122, 1, 122, 3, 122, 3854, 8, 122, 1, 122, 1, 122, 3, 122, 3858, 8, + 122, 1, 122, 1, 122, 5, 122, 3862, 8, 122, 10, 122, 12, 122, 3865, 9, 122, + 1, 122, 1, 122, 1, 122, 3, 122, 3870, 8, 122, 3, 122, 3872, 8, 122, 1, + 122, 1, 122, 3, 122, 3876, 8, 122, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, + 1, 123, 1, 123, 3, 123, 3885, 8, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, + 124, 1, 124, 1, 124, 1, 124, 3, 124, 3895, 8, 124, 1, 125, 1, 125, 1, 125, + 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 3, 125, 3905, 8, 125, 1, 126, 1, + 126, 5, 126, 3909, 8, 126, 10, 126, 12, 126, 3912, 9, 126, 1, 126, 1, 126, + 3, 126, 3916, 8, 126, 1, 126, 1, 126, 3, 126, 3920, 8, 126, 1, 126, 3, + 126, 3923, 8, 126, 1, 126, 3, 126, 3926, 8, 126, 1, 126, 3, 126, 3929, + 8, 126, 1, 126, 3, 126, 3932, 8, 126, 1, 126, 1, 126, 5, 126, 3936, 8, + 126, 10, 126, 12, 126, 3939, 9, 126, 1, 126, 1, 126, 1, 126, 3, 126, 3944, + 8, 126, 1, 126, 3, 126, 3947, 8, 126, 1, 126, 3, 126, 3950, 8, 126, 1, + 126, 3, 126, 3953, 8, 126, 1, 126, 3, 126, 3956, 8, 126, 1, 126, 3, 126, + 3959, 8, 126, 3, 126, 3961, 8, 126, 1, 127, 1, 127, 5, 127, 3965, 8, 127, + 10, 127, 12, 127, 3968, 9, 127, 1, 127, 1, 127, 1, 127, 3, 127, 3973, 8, + 127, 1, 127, 3, 127, 3976, 8, 127, 1, 127, 3, 127, 3979, 8, 127, 1, 127, + 3, 127, 3982, 8, 127, 1, 127, 3, 127, 3985, 8, 127, 1, 127, 3, 127, 3988, + 8, 127, 1, 128, 1, 128, 3, 128, 3992, 8, 128, 1, 128, 1, 128, 1, 129, 1, + 129, 3, 129, 3998, 8, 129, 1, 129, 1, 129, 3, 129, 4002, 8, 129, 1, 130, + 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 3, 130, 4010, 8, 130, 1, 130, 1, + 130, 3, 130, 4014, 8, 130, 1, 130, 3, 130, 4017, 8, 130, 3, 130, 4019, + 8, 130, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, + 1, 131, 1, 131, 1, 131, 3, 131, 4032, 8, 131, 1, 131, 3, 131, 4035, 8, + 131, 1, 132, 1, 132, 1, 132, 5, 132, 4040, 8, 132, 10, 132, 12, 132, 4043, + 9, 132, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 3, 133, + 4052, 8, 133, 1, 133, 3, 133, 4055, 8, 133, 1, 133, 1, 133, 1, 133, 3, + 133, 4060, 8, 133, 3, 133, 4062, 8, 133, 1, 133, 1, 133, 3, 133, 4066, + 8, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 3, 133, 4074, 8, + 133, 1, 134, 1, 134, 1, 134, 1, 134, 3, 134, 4080, 8, 134, 1, 134, 1, 134, + 1, 134, 1, 135, 1, 135, 1, 135, 1, 135, 3, 135, 4089, 8, 135, 1, 135, 1, + 135, 1, 135, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, + 136, 3, 136, 4102, 8, 136, 1, 137, 1, 137, 3, 137, 4106, 8, 137, 1, 137, + 1, 137, 5, 137, 4110, 8, 137, 10, 137, 12, 137, 4113, 9, 137, 1, 138, 1, + 138, 1, 138, 1, 138, 1, 138, 1, 138, 3, 138, 4121, 8, 138, 1, 138, 3, 138, + 4124, 8, 138, 1, 138, 1, 138, 3, 138, 4128, 8, 138, 1, 138, 3, 138, 4131, + 8, 138, 1, 138, 1, 138, 3, 138, 4135, 8, 138, 1, 138, 1, 138, 3, 138, 4139, + 8, 138, 1, 138, 3, 138, 4142, 8, 138, 3, 138, 4144, 8, 138, 1, 139, 1, + 139, 1, 139, 1, 139, 5, 139, 4150, 8, 139, 10, 139, 12, 139, 4153, 9, 139, + 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, + 3, 139, 4164, 8, 139, 1, 139, 1, 139, 4, 139, 4168, 8, 139, 11, 139, 12, + 139, 4169, 3, 139, 4172, 8, 139, 1, 139, 1, 139, 4, 139, 4176, 8, 139, + 11, 139, 12, 139, 4177, 3, 139, 4180, 8, 139, 3, 139, 4182, 8, 139, 1, + 140, 1, 140, 1, 140, 1, 140, 3, 140, 4188, 8, 140, 1, 140, 1, 140, 1, 140, + 1, 140, 1, 140, 1, 140, 3, 140, 4196, 8, 140, 1, 141, 1, 141, 1, 141, 1, + 141, 1, 141, 1, 141, 3, 141, 4204, 8, 141, 1, 142, 1, 142, 3, 142, 4208, + 8, 142, 1, 142, 1, 142, 3, 142, 4212, 8, 142, 1, 143, 1, 143, 1, 143, 1, + 143, 1, 143, 5, 143, 4219, 8, 143, 10, 143, 12, 143, 4222, 9, 143, 1, 143, + 1, 143, 3, 143, 4226, 8, 143, 1, 144, 1, 144, 1, 144, 1, 145, 1, 145, 1, + 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, + 145, 1, 145, 5, 145, 4244, 8, 145, 10, 145, 12, 145, 4247, 9, 145, 1, 146, + 1, 146, 3, 146, 4251, 8, 146, 1, 147, 1, 147, 1, 147, 1, 147, 3, 147, 4257, + 8, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 3, 147, 4264, 8, 147, 1, + 148, 1, 148, 1, 148, 3, 148, 4269, 8, 148, 1, 149, 1, 149, 1, 149, 1, 149, + 1, 149, 5, 149, 4276, 8, 149, 10, 149, 12, 149, 4279, 9, 149, 3, 149, 4281, + 8, 149, 1, 150, 1, 150, 3, 150, 4285, 8, 150, 1, 151, 1, 151, 3, 151, 4289, + 8, 151, 1, 151, 1, 151, 3, 151, 4293, 8, 151, 1, 151, 3, 151, 4296, 8, + 151, 1, 151, 3, 151, 4299, 8, 151, 1, 151, 3, 151, 4302, 8, 151, 1, 152, + 1, 152, 3, 152, 4306, 8, 152, 1, 152, 1, 152, 3, 152, 4310, 8, 152, 1, + 152, 3, 152, 4313, 8, 152, 1, 152, 3, 152, 4316, 8, 152, 1, 152, 3, 152, + 4319, 8, 152, 1, 153, 1, 153, 1, 153, 1, 154, 1, 154, 3, 154, 4326, 8, + 154, 1, 154, 1, 154, 3, 154, 4330, 8, 154, 1, 154, 1, 154, 1, 155, 1, 155, + 1, 155, 1, 155, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 5, 156, 4343, 8, + 156, 10, 156, 12, 156, 4346, 9, 156, 1, 156, 3, 156, 4349, 8, 156, 1, 157, + 1, 157, 1, 157, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 159, 1, 159, + 3, 159, 4361, 8, 159, 1, 159, 1, 159, 1, 159, 1, 159, 5, 159, 4367, 8, + 159, 10, 159, 12, 159, 4370, 9, 159, 1, 160, 1, 160, 1, 160, 1, 160, 1, + 160, 1, 160, 1, 160, 3, 160, 4379, 8, 160, 1, 161, 1, 161, 3, 161, 4383, + 8, 161, 1, 161, 3, 161, 4386, 8, 161, 1, 161, 1, 161, 1, 162, 1, 162, 3, + 162, 4392, 8, 162, 1, 162, 3, 162, 4395, 8, 162, 1, 162, 3, 162, 4398, + 8, 162, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 3, 163, + 4407, 8, 163, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 3, + 164, 4416, 8, 164, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 5, 165, + 4424, 8, 165, 10, 165, 12, 165, 4427, 9, 165, 1, 165, 3, 165, 4430, 8, + 165, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 5, 166, 4438, 8, 166, + 10, 166, 12, 166, 4441, 9, 166, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, + 1, 167, 1, 167, 3, 167, 4450, 8, 167, 1, 168, 1, 168, 1, 168, 1, 169, 1, + 169, 1, 169, 3, 169, 4458, 8, 169, 1, 169, 3, 169, 4461, 8, 169, 1, 170, + 1, 170, 1, 170, 1, 170, 1, 170, 5, 170, 4468, 8, 170, 10, 170, 12, 170, + 4471, 9, 170, 3, 170, 4473, 8, 170, 1, 170, 1, 170, 3, 170, 4477, 8, 170, + 1, 170, 5, 170, 4480, 8, 170, 10, 170, 12, 170, 4483, 9, 170, 1, 170, 3, + 170, 4486, 8, 170, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 5, 171, 4493, + 8, 171, 10, 171, 12, 171, 4496, 9, 171, 3, 171, 4498, 8, 171, 1, 172, 1, + 172, 1, 172, 1, 173, 1, 173, 1, 173, 1, 174, 1, 174, 1, 174, 1, 174, 1, + 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, + 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 5, 174, 4527, + 8, 174, 10, 174, 12, 174, 4530, 9, 174, 3, 174, 4532, 8, 174, 1, 174, 3, + 174, 4535, 8, 174, 1, 175, 1, 175, 1, 176, 1, 176, 1, 177, 1, 177, 1, 178, + 1, 178, 1, 178, 1, 178, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, + 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, + 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, + 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, + 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, + 5, 179, 4589, 8, 179, 10, 179, 12, 179, 4592, 9, 179, 1, 179, 1, 179, 3, + 179, 4596, 8, 179, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 181, + 1, 181, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, + 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, + 1, 182, 3, 182, 4624, 8, 182, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, + 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 3, 183, 4638, 8, 183, + 1, 184, 1, 184, 1, 184, 5, 184, 4643, 8, 184, 10, 184, 12, 184, 4646, 9, + 184, 1, 184, 3, 184, 4649, 8, 184, 1, 185, 1, 185, 1, 185, 1, 185, 3, 185, + 4655, 8, 185, 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, 3, 186, 4663, + 8, 186, 3, 186, 4665, 8, 186, 1, 187, 1, 187, 1, 187, 1, 187, 1, 188, 1, + 188, 1, 188, 1, 188, 1, 188, 3, 188, 4676, 8, 188, 1, 189, 1, 189, 1, 189, + 1, 189, 1, 190, 1, 190, 1, 190, 1, 190, 3, 190, 4686, 8, 190, 1, 191, 1, + 191, 1, 191, 1, 191, 1, 191, 3, 191, 4693, 8, 191, 1, 192, 1, 192, 1, 192, + 1, 192, 3, 192, 4699, 8, 192, 1, 193, 1, 193, 1, 193, 1, 193, 1, 194, 1, + 194, 3, 194, 4707, 8, 194, 1, 195, 1, 195, 1, 195, 3, 195, 4712, 8, 195, + 1, 195, 1, 195, 1, 195, 1, 195, 5, 195, 4718, 8, 195, 10, 195, 12, 195, + 4721, 9, 195, 1, 195, 1, 195, 1, 195, 5, 195, 4726, 8, 195, 10, 195, 12, + 195, 4729, 9, 195, 1, 195, 1, 195, 1, 195, 5, 195, 4734, 8, 195, 10, 195, + 12, 195, 4737, 9, 195, 1, 195, 1, 195, 1, 195, 5, 195, 4742, 8, 195, 10, + 195, 12, 195, 4745, 9, 195, 1, 195, 5, 195, 4748, 8, 195, 10, 195, 12, + 195, 4751, 9, 195, 1, 195, 1, 195, 3, 195, 4755, 8, 195, 1, 196, 1, 196, + 1, 196, 3, 196, 4760, 8, 196, 1, 196, 4, 196, 4763, 8, 196, 11, 196, 12, + 196, 4764, 1, 196, 1, 196, 4, 196, 4769, 8, 196, 11, 196, 12, 196, 4770, + 3, 196, 4773, 8, 196, 1, 196, 1, 196, 1, 196, 1, 197, 1, 197, 1, 197, 1, + 197, 4, 197, 4782, 8, 197, 11, 197, 12, 197, 4783, 1, 197, 5, 197, 4787, + 8, 197, 10, 197, 12, 197, 4790, 9, 197, 1, 197, 1, 197, 4, 197, 4794, 8, + 197, 11, 197, 12, 197, 4795, 3, 197, 4798, 8, 197, 1, 197, 1, 197, 1, 197, + 1, 198, 1, 198, 1, 198, 1, 199, 1, 199, 1, 199, 1, 200, 1, 200, 1, 200, + 3, 200, 4812, 8, 200, 1, 200, 1, 200, 4, 200, 4816, 8, 200, 11, 200, 12, + 200, 4817, 1, 200, 1, 200, 1, 200, 3, 200, 4823, 8, 200, 1, 201, 1, 201, + 1, 201, 3, 201, 4828, 8, 201, 1, 201, 1, 201, 4, 201, 4832, 8, 201, 11, + 201, 12, 201, 4833, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 3, 201, 4841, + 8, 201, 1, 202, 1, 202, 1, 202, 1, 203, 1, 203, 1, 203, 3, 203, 4849, 8, + 203, 1, 203, 1, 203, 1, 203, 1, 203, 4, 203, 4855, 8, 203, 11, 203, 12, + 203, 4856, 1, 203, 1, 203, 1, 203, 3, 203, 4862, 8, 203, 1, 204, 1, 204, + 1, 204, 1, 204, 3, 204, 4868, 8, 204, 1, 204, 3, 204, 4871, 8, 204, 1, + 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 3, 204, 4879, 8, 204, 1, 205, + 1, 205, 1, 205, 1, 205, 1, 205, 3, 205, 4886, 8, 205, 1, 206, 1, 206, 1, + 206, 1, 206, 1, 206, 1, 206, 1, 206, 3, 206, 4895, 8, 206, 1, 206, 3, 206, + 4898, 8, 206, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 208, 1, + 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 5, 208, 4913, 8, 208, 10, + 208, 12, 208, 4916, 9, 208, 1, 208, 1, 208, 1, 209, 1, 209, 1, 209, 3, + 209, 4923, 8, 209, 1, 209, 1, 209, 1, 209, 1, 209, 1, 209, 1, 209, 3, 209, + 4931, 8, 209, 1, 210, 1, 210, 3, 210, 4935, 8, 210, 1, 210, 1, 210, 1, + 211, 1, 211, 1, 211, 3, 211, 4942, 8, 211, 1, 211, 1, 211, 4, 211, 4946, + 8, 211, 11, 211, 12, 211, 4947, 1, 212, 1, 212, 1, 212, 1, 212, 4, 212, + 4954, 8, 212, 11, 212, 12, 212, 4955, 1, 213, 1, 213, 1, 213, 1, 213, 1, + 213, 5, 213, 4963, 8, 213, 10, 213, 12, 213, 4966, 9, 213, 1, 213, 1, 213, + 1, 213, 3, 213, 4971, 8, 213, 1, 213, 1, 213, 1, 213, 5, 213, 4976, 8, + 213, 10, 213, 12, 213, 4979, 9, 213, 1, 213, 1, 213, 1, 213, 1, 213, 3, + 213, 4985, 8, 213, 1, 213, 5, 213, 4988, 8, 213, 10, 213, 12, 213, 4991, + 9, 213, 3, 213, 4993, 8, 213, 3, 213, 4995, 8, 213, 1, 213, 1, 213, 4, + 213, 4999, 8, 213, 11, 213, 12, 213, 5000, 3, 213, 5003, 8, 213, 1, 213, + 1, 213, 5, 213, 5007, 8, 213, 10, 213, 12, 213, 5010, 9, 213, 1, 213, 1, + 213, 1, 213, 1, 213, 3, 213, 5016, 8, 213, 1, 213, 1, 213, 1, 213, 3, 213, + 5021, 8, 213, 1, 213, 1, 213, 3, 213, 5025, 8, 213, 1, 213, 1, 213, 1, + 213, 1, 213, 3, 213, 5031, 8, 213, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, + 5, 214, 5038, 8, 214, 10, 214, 12, 214, 5041, 9, 214, 1, 214, 1, 214, 1, + 214, 3, 214, 5046, 8, 214, 1, 214, 1, 214, 1, 214, 5, 214, 5051, 8, 214, + 10, 214, 12, 214, 5054, 9, 214, 1, 214, 1, 214, 1, 214, 3, 214, 5059, 8, + 214, 1, 214, 1, 214, 1, 214, 1, 214, 3, 214, 5065, 8, 214, 1, 214, 5, 214, + 5068, 8, 214, 10, 214, 12, 214, 5071, 9, 214, 3, 214, 5073, 8, 214, 3, + 214, 5075, 8, 214, 1, 214, 1, 214, 4, 214, 5079, 8, 214, 11, 214, 12, 214, + 5080, 3, 214, 5083, 8, 214, 1, 214, 1, 214, 5, 214, 5087, 8, 214, 10, 214, + 12, 214, 5090, 9, 214, 1, 214, 1, 214, 1, 214, 1, 214, 3, 214, 5096, 8, + 214, 3, 214, 5098, 8, 214, 1, 215, 1, 215, 1, 215, 3, 215, 5103, 8, 215, + 1, 215, 1, 215, 1, 215, 5, 215, 5108, 8, 215, 10, 215, 12, 215, 5111, 9, + 215, 1, 216, 1, 216, 1, 216, 1, 216, 5, 216, 5117, 8, 216, 10, 216, 12, + 216, 5120, 9, 216, 1, 216, 1, 216, 3, 216, 5124, 8, 216, 1, 216, 1, 216, + 1, 216, 1, 216, 1, 216, 5, 216, 5131, 8, 216, 10, 216, 12, 216, 5134, 9, + 216, 1, 216, 1, 216, 1, 216, 1, 216, 3, 216, 5140, 8, 216, 1, 216, 5, 216, + 5143, 8, 216, 10, 216, 12, 216, 5146, 9, 216, 3, 216, 5148, 8, 216, 3, + 216, 5150, 8, 216, 1, 216, 1, 216, 1, 216, 1, 216, 5, 216, 5156, 8, 216, + 10, 216, 12, 216, 5159, 9, 216, 3, 216, 5161, 8, 216, 1, 216, 1, 216, 1, + 216, 1, 216, 1, 216, 1, 216, 3, 216, 5169, 8, 216, 1, 216, 1, 216, 1, 216, + 3, 216, 5174, 8, 216, 1, 216, 1, 216, 1, 216, 3, 216, 5179, 8, 216, 5, + 216, 5181, 8, 216, 10, 216, 12, 216, 5184, 9, 216, 1, 216, 1, 216, 1, 216, + 3, 216, 5189, 8, 216, 1, 216, 1, 216, 1, 216, 3, 216, 5194, 8, 216, 5, + 216, 5196, 8, 216, 10, 216, 12, 216, 5199, 9, 216, 1, 216, 1, 216, 1, 216, + 3, 216, 5204, 8, 216, 3, 216, 5206, 8, 216, 1, 217, 1, 217, 1, 217, 1, + 217, 1, 217, 1, 217, 1, 217, 5, 217, 5215, 8, 217, 10, 217, 12, 217, 5218, + 9, 217, 3, 217, 5220, 8, 217, 1, 217, 1, 217, 1, 217, 5, 217, 5225, 8, + 217, 10, 217, 12, 217, 5228, 9, 217, 3, 217, 5230, 8, 217, 1, 218, 1, 218, + 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 5, 218, 5240, 8, 218, 10, + 218, 12, 218, 5243, 9, 218, 1, 218, 1, 218, 1, 218, 3, 218, 5248, 8, 218, + 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 5, 219, 5255, 8, 219, 10, 219, + 12, 219, 5258, 9, 219, 1, 220, 1, 220, 3, 220, 5262, 8, 220, 1, 220, 1, + 220, 3, 220, 5266, 8, 220, 1, 220, 1, 220, 1, 220, 5, 220, 5271, 8, 220, + 10, 220, 12, 220, 5274, 9, 220, 1, 220, 1, 220, 3, 220, 5278, 8, 220, 1, + 220, 1, 220, 1, 220, 1, 220, 1, 220, 5, 220, 5285, 8, 220, 10, 220, 12, + 220, 5288, 9, 220, 1, 220, 1, 220, 1, 220, 3, 220, 5293, 8, 220, 1, 220, + 1, 220, 3, 220, 5297, 8, 220, 1, 220, 1, 220, 3, 220, 5301, 8, 220, 1, + 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 5, 220, 5310, 8, 220, + 10, 220, 12, 220, 5313, 9, 220, 1, 220, 1, 220, 1, 220, 3, 220, 5318, 8, + 220, 1, 220, 1, 220, 3, 220, 5322, 8, 220, 1, 220, 1, 220, 3, 220, 5326, + 8, 220, 1, 220, 1, 220, 1, 220, 3, 220, 5331, 8, 220, 5, 220, 5333, 8, + 220, 10, 220, 12, 220, 5336, 9, 220, 1, 220, 1, 220, 1, 220, 3, 220, 5341, + 8, 220, 1, 220, 1, 220, 1, 220, 3, 220, 5346, 8, 220, 5, 220, 5348, 8, + 220, 10, 220, 12, 220, 5351, 9, 220, 1, 220, 1, 220, 1, 220, 3, 220, 5356, + 8, 220, 3, 220, 5358, 8, 220, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, + 221, 1, 221, 1, 221, 5, 221, 5368, 8, 221, 10, 221, 12, 221, 5371, 9, 221, + 1, 222, 1, 222, 1, 222, 1, 222, 3, 222, 5377, 8, 222, 1, 222, 1, 222, 1, + 222, 3, 222, 5382, 8, 222, 1, 223, 1, 223, 1, 223, 1, 224, 1, 224, 1, 224, + 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, + 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, + 1, 224, 1, 224, 1, 224, 1, 224, 3, 224, 5412, 8, 224, 1, 225, 1, 225, 3, + 225, 5416, 8, 225, 1, 225, 1, 225, 1, 225, 3, 225, 5421, 8, 225, 1, 226, + 1, 226, 1, 226, 1, 226, 1, 226, 3, 226, 5428, 8, 226, 1, 226, 3, 226, 5431, + 8, 226, 1, 226, 1, 226, 1, 226, 1, 226, 3, 226, 5437, 8, 226, 1, 227, 1, + 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 3, 227, 5447, 8, 227, + 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 3, 228, + 5457, 8, 228, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, + 229, 3, 229, 5467, 8, 229, 1, 229, 1, 229, 1, 229, 1, 229, 3, 229, 5473, + 8, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 3, 229, + 5482, 8, 229, 1, 229, 1, 229, 1, 229, 1, 229, 3, 229, 5488, 8, 229, 1, + 229, 1, 229, 1, 229, 1, 229, 1, 229, 3, 229, 5495, 8, 229, 3, 229, 5497, + 8, 229, 1, 230, 1, 230, 1, 230, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, + 3, 231, 5507, 8, 231, 1, 232, 1, 232, 3, 232, 5511, 8, 232, 1, 232, 1, + 232, 3, 232, 5515, 8, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, + 1, 232, 1, 232, 3, 232, 5525, 8, 232, 1, 232, 1, 232, 1, 232, 3, 232, 5530, + 8, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, + 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, + 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, + 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, + 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, + 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, + 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, + 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 3, 232, + 5602, 8, 232, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, + 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 3, + 233, 5620, 8, 233, 1, 234, 1, 234, 1, 234, 1, 234, 1, 235, 1, 235, 3, 235, + 5628, 8, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, + 235, 5, 235, 5638, 8, 235, 10, 235, 12, 235, 5641, 9, 235, 1, 235, 1, 235, + 1, 235, 1, 235, 3, 235, 5647, 8, 235, 3, 235, 5649, 8, 235, 1, 235, 1, + 235, 1, 235, 1, 235, 1, 235, 1, 235, 5, 235, 5657, 8, 235, 10, 235, 12, + 235, 5660, 9, 235, 3, 235, 5662, 8, 235, 1, 236, 1, 236, 1, 236, 1, 236, + 5, 236, 5668, 8, 236, 10, 236, 12, 236, 5671, 9, 236, 1, 237, 1, 237, 1, + 237, 1, 237, 3, 237, 5677, 8, 237, 1, 238, 1, 238, 3, 238, 5681, 8, 238, + 1, 238, 1, 238, 1, 238, 1, 239, 1, 239, 3, 239, 5688, 8, 239, 1, 239, 1, + 239, 1, 239, 3, 239, 5693, 8, 239, 1, 239, 3, 239, 5696, 8, 239, 1, 239, + 3, 239, 5699, 8, 239, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, + 240, 3, 240, 5708, 8, 240, 1, 241, 1, 241, 3, 241, 5712, 8, 241, 1, 241, + 1, 241, 3, 241, 5716, 8, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, + 241, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 243, 1, 243, 1, + 243, 1, 243, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 3, 244, 5739, 8, 244, + 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 3, 244, 5746, 8, 244, 5, 244, 5748, + 8, 244, 10, 244, 12, 244, 5751, 9, 244, 1, 244, 1, 244, 1, 244, 1, 244, + 3, 244, 5757, 8, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 3, 244, 5764, + 8, 244, 1, 244, 3, 244, 5767, 8, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, + 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 5, 244, 5781, + 8, 244, 10, 244, 12, 244, 5784, 9, 244, 3, 244, 5786, 8, 244, 1, 245, 1, + 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 3, 245, 5796, 8, 245, + 1, 245, 1, 245, 3, 245, 5800, 8, 245, 1, 245, 1, 245, 1, 245, 1, 245, 3, + 245, 5806, 8, 245, 1, 245, 3, 245, 5809, 8, 245, 1, 245, 1, 245, 1, 245, + 3, 245, 5814, 8, 245, 1, 245, 1, 245, 3, 245, 5818, 8, 245, 1, 245, 1, + 245, 1, 245, 1, 245, 1, 245, 3, 245, 5825, 8, 245, 1, 245, 3, 245, 5828, + 8, 245, 1, 245, 1, 245, 1, 245, 1, 245, 3, 245, 5834, 8, 245, 1, 245, 1, + 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, + 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, + 245, 1, 245, 1, 245, 3, 245, 5858, 8, 245, 1, 245, 3, 245, 5861, 8, 245, + 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, + 1, 245, 3, 245, 5873, 8, 245, 1, 245, 3, 245, 5876, 8, 245, 1, 245, 1, + 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 3, 245, 5886, 8, 245, + 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 3, 245, 5894, 8, 245, 1, + 245, 1, 245, 3, 245, 5898, 8, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, + 3, 245, 5905, 8, 245, 1, 245, 3, 245, 5908, 8, 245, 1, 245, 1, 245, 1, + 245, 1, 245, 1, 245, 5, 245, 5915, 8, 245, 10, 245, 12, 245, 5918, 9, 245, + 1, 245, 1, 245, 1, 245, 3, 245, 5923, 8, 245, 1, 245, 1, 245, 1, 245, 1, + 245, 3, 245, 5929, 8, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, + 1, 245, 1, 245, 3, 245, 5939, 8, 245, 3, 245, 5941, 8, 245, 1, 246, 1, + 246, 1, 246, 1, 246, 3, 246, 5947, 8, 246, 1, 246, 3, 246, 5950, 8, 246, + 1, 246, 3, 246, 5953, 8, 246, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, + 247, 1, 247, 1, 247, 1, 247, 1, 247, 3, 247, 5965, 8, 247, 1, 247, 3, 247, + 5968, 8, 247, 1, 248, 1, 248, 1, 248, 1, 248, 3, 248, 5974, 8, 248, 1, + 249, 3, 249, 5977, 8, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, + 3, 249, 5985, 8, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 3, + 249, 5993, 8, 249, 1, 250, 1, 250, 1, 250, 1, 250, 3, 250, 5999, 8, 250, + 1, 250, 1, 250, 3, 250, 6003, 8, 250, 1, 251, 1, 251, 1, 251, 1, 251, 1, + 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 3, 251, 6017, + 8, 251, 1, 252, 1, 252, 1, 252, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, + 5, 253, 6027, 8, 253, 10, 253, 12, 253, 6030, 9, 253, 1, 253, 1, 253, 1, + 253, 1, 253, 3, 253, 6036, 8, 253, 1, 253, 3, 253, 6039, 8, 253, 1, 253, + 1, 253, 1, 253, 1, 254, 1, 254, 3, 254, 6046, 8, 254, 1, 254, 1, 254, 1, + 254, 5, 254, 6051, 8, 254, 10, 254, 12, 254, 6054, 9, 254, 1, 255, 1, 255, + 3, 255, 6058, 8, 255, 1, 255, 1, 255, 1, 256, 1, 256, 1, 256, 1, 256, 1, + 256, 1, 256, 1, 256, 5, 256, 6069, 8, 256, 10, 256, 12, 256, 6072, 9, 256, + 1, 257, 1, 257, 1, 257, 1, 257, 1, 258, 1, 258, 1, 259, 1, 259, 3, 259, + 6082, 8, 259, 1, 259, 1, 259, 1, 259, 1, 259, 3, 259, 6088, 8, 259, 1, + 260, 1, 260, 1, 260, 3, 260, 6093, 8, 260, 1, 260, 1, 260, 1, 260, 1, 260, + 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 3, 260, 6106, 8, + 260, 3, 260, 6108, 8, 260, 1, 260, 1, 260, 1, 260, 3, 260, 6113, 8, 260, + 1, 260, 1, 260, 3, 260, 6117, 8, 260, 1, 260, 3, 260, 6120, 8, 260, 3, + 260, 6122, 8, 260, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 3, 261, 6129, + 8, 261, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 3, 262, 6136, 8, 262, 1, + 262, 3, 262, 6139, 8, 262, 1, 262, 3, 262, 6142, 8, 262, 1, 262, 1, 262, + 1, 262, 1, 262, 3, 262, 6148, 8, 262, 1, 262, 1, 262, 3, 262, 6152, 8, + 262, 1, 263, 1, 263, 1, 263, 1, 263, 3, 263, 6158, 8, 263, 1, 264, 1, 264, + 1, 264, 1, 264, 3, 264, 6164, 8, 264, 1, 264, 1, 264, 1, 265, 1, 265, 1, + 265, 1, 266, 1, 266, 1, 266, 1, 267, 1, 267, 1, 267, 3, 267, 6177, 8, 267, + 1, 267, 1, 267, 1, 267, 3, 267, 6182, 8, 267, 1, 267, 1, 267, 1, 267, 1, + 267, 5, 267, 6188, 8, 267, 10, 267, 12, 267, 6191, 9, 267, 3, 267, 6193, + 8, 267, 1, 268, 1, 268, 1, 268, 3, 268, 6198, 8, 268, 1, 268, 1, 268, 1, + 268, 3, 268, 6203, 8, 268, 1, 268, 1, 268, 1, 268, 1, 268, 5, 268, 6209, + 8, 268, 10, 268, 12, 268, 6212, 9, 268, 3, 268, 6214, 8, 268, 1, 269, 1, + 269, 1, 269, 1, 269, 1, 269, 1, 269, 3, 269, 6222, 8, 269, 1, 270, 1, 270, + 3, 270, 6226, 8, 270, 1, 270, 1, 270, 1, 270, 5, 270, 6231, 8, 270, 10, + 270, 12, 270, 6234, 9, 270, 1, 271, 1, 271, 1, 271, 3, 271, 6239, 8, 271, + 1, 271, 3, 271, 6242, 8, 271, 1, 272, 1, 272, 3, 272, 6246, 8, 272, 1, + 272, 1, 272, 1, 272, 1, 272, 1, 272, 1, 272, 1, 272, 1, 272, 1, 272, 5, + 272, 6257, 8, 272, 10, 272, 12, 272, 6260, 9, 272, 1, 272, 1, 272, 1, 272, + 3, 272, 6265, 8, 272, 1, 272, 1, 272, 1, 272, 1, 272, 1, 272, 1, 272, 1, + 272, 1, 272, 5, 272, 6275, 8, 272, 10, 272, 12, 272, 6278, 9, 272, 3, 272, + 6280, 8, 272, 1, 273, 1, 273, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 3, + 274, 6289, 8, 274, 1, 274, 1, 274, 1, 274, 3, 274, 6294, 8, 274, 1, 275, + 1, 275, 1, 275, 1, 275, 3, 275, 6300, 8, 275, 1, 276, 1, 276, 1, 277, 1, + 277, 3, 277, 6306, 8, 277, 1, 278, 1, 278, 1, 278, 3, 278, 6311, 8, 278, + 3, 278, 6313, 8, 278, 1, 278, 3, 278, 6316, 8, 278, 1, 278, 1, 278, 3, + 278, 6320, 8, 278, 3, 278, 6322, 8, 278, 1, 279, 1, 279, 3, 279, 6326, + 8, 279, 1, 279, 1, 279, 1, 279, 1, 279, 3, 279, 6332, 8, 279, 1, 279, 3, + 279, 6335, 8, 279, 1, 279, 3, 279, 6338, 8, 279, 1, 280, 1, 280, 1, 280, + 1, 280, 3, 280, 6344, 8, 280, 1, 281, 1, 281, 1, 282, 1, 282, 1, 282, 1, + 282, 1, 282, 3, 282, 6353, 8, 282, 1, 283, 1, 283, 1, 284, 1, 284, 1, 284, + 1, 284, 3, 284, 6361, 8, 284, 1, 285, 1, 285, 3, 285, 6365, 8, 285, 1, + 286, 1, 286, 1, 286, 3, 286, 6370, 8, 286, 1, 287, 1, 287, 1, 288, 1, 288, + 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, + 1, 288, 1, 288, 1, 288, 4, 288, 6388, 8, 288, 11, 288, 12, 288, 6389, 1, + 289, 1, 289, 1, 289, 1, 289, 1, 289, 3, 289, 6397, 8, 289, 3, 289, 6399, + 8, 289, 1, 290, 1, 290, 1, 290, 4, 290, 6404, 8, 290, 11, 290, 12, 290, + 6405, 3, 290, 6408, 8, 290, 1, 291, 1, 291, 3, 291, 6412, 8, 291, 1, 292, + 1, 292, 1, 292, 3, 292, 6417, 8, 292, 1, 293, 1, 293, 1, 293, 1, 293, 1, + 293, 1, 293, 1, 293, 1, 293, 1, 293, 3, 293, 6428, 8, 293, 1, 294, 1, 294, + 1, 294, 3, 294, 6433, 8, 294, 1, 295, 1, 295, 1, 296, 1, 296, 3, 296, 6439, + 8, 296, 1, 297, 3, 297, 6442, 8, 297, 1, 297, 1, 297, 3, 297, 6446, 8, + 297, 1, 297, 4, 297, 6449, 8, 297, 11, 297, 12, 297, 6450, 1, 297, 3, 297, + 6454, 8, 297, 1, 297, 1, 297, 3, 297, 6458, 8, 297, 1, 297, 1, 297, 3, + 297, 6462, 8, 297, 3, 297, 6464, 8, 297, 1, 298, 1, 298, 1, 299, 3, 299, + 6469, 8, 299, 1, 299, 1, 299, 1, 300, 3, 300, 6474, 8, 300, 1, 300, 1, + 300, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, + 301, 3, 301, 6487, 8, 301, 1, 301, 3, 301, 6490, 8, 301, 1, 302, 1, 302, + 3, 302, 6494, 8, 302, 1, 302, 3, 302, 6497, 8, 302, 1, 302, 3, 302, 6500, + 8, 302, 1, 302, 1, 302, 1, 302, 3, 302, 6505, 8, 302, 1, 302, 1, 302, 1, + 302, 3, 302, 6510, 8, 302, 1, 302, 1, 302, 1, 302, 1, 302, 3, 302, 6516, + 8, 302, 1, 302, 3, 302, 6519, 8, 302, 1, 302, 1, 302, 1, 302, 3, 302, 6524, + 8, 302, 1, 302, 3, 302, 6527, 8, 302, 1, 302, 1, 302, 1, 302, 3, 302, 6532, + 8, 302, 1, 302, 3, 302, 6535, 8, 302, 1, 302, 1, 302, 3, 302, 6539, 8, + 302, 1, 302, 5, 302, 6542, 8, 302, 10, 302, 12, 302, 6545, 9, 302, 1, 302, + 1, 302, 3, 302, 6549, 8, 302, 1, 302, 5, 302, 6552, 8, 302, 10, 302, 12, + 302, 6555, 9, 302, 1, 302, 1, 302, 3, 302, 6559, 8, 302, 1, 302, 3, 302, + 6562, 8, 302, 1, 302, 5, 302, 6565, 8, 302, 10, 302, 12, 302, 6568, 9, + 302, 1, 302, 1, 302, 3, 302, 6572, 8, 302, 1, 302, 5, 302, 6575, 8, 302, + 10, 302, 12, 302, 6578, 9, 302, 1, 302, 1, 302, 1, 302, 3, 302, 6583, 8, + 302, 1, 302, 1, 302, 1, 302, 3, 302, 6588, 8, 302, 1, 302, 1, 302, 1, 302, + 3, 302, 6593, 8, 302, 1, 302, 1, 302, 1, 302, 3, 302, 6598, 8, 302, 1, + 302, 1, 302, 3, 302, 6602, 8, 302, 1, 302, 3, 302, 6605, 8, 302, 1, 302, + 1, 302, 1, 302, 3, 302, 6610, 8, 302, 1, 302, 1, 302, 3, 302, 6614, 8, + 302, 1, 302, 1, 302, 3, 302, 6618, 8, 302, 1, 303, 1, 303, 1, 303, 1, 303, + 5, 303, 6624, 8, 303, 10, 303, 12, 303, 6627, 9, 303, 1, 303, 1, 303, 1, + 304, 1, 304, 3, 304, 6633, 8, 304, 1, 304, 1, 304, 3, 304, 6637, 8, 304, + 1, 304, 1, 304, 1, 304, 3, 304, 6642, 8, 304, 1, 304, 1, 304, 1, 304, 3, + 304, 6647, 8, 304, 1, 304, 1, 304, 3, 304, 6651, 8, 304, 3, 304, 6653, + 8, 304, 1, 304, 3, 304, 6656, 8, 304, 1, 305, 1, 305, 1, 305, 1, 305, 1, + 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, 307, 1, 307, 1, 307, 1, + 307, 3, 307, 6672, 8, 307, 1, 307, 1, 307, 1, 308, 1, 308, 1, 308, 5, 308, + 6679, 8, 308, 10, 308, 12, 308, 6682, 9, 308, 1, 309, 1, 309, 1, 309, 5, + 309, 6687, 8, 309, 10, 309, 12, 309, 6690, 9, 309, 1, 310, 1, 310, 1, 310, + 5, 310, 6695, 8, 310, 10, 310, 12, 310, 6698, 9, 310, 1, 311, 1, 311, 1, + 311, 1, 311, 5, 311, 6704, 8, 311, 10, 311, 12, 311, 6707, 9, 311, 1, 311, + 1, 311, 1, 312, 1, 312, 1, 312, 5, 312, 6714, 8, 312, 10, 312, 12, 312, + 6717, 9, 312, 1, 313, 1, 313, 1, 313, 5, 313, 6722, 8, 313, 10, 313, 12, + 313, 6725, 9, 313, 1, 314, 1, 314, 1, 314, 5, 314, 6730, 8, 314, 10, 314, + 12, 314, 6733, 9, 314, 1, 315, 1, 315, 1, 315, 5, 315, 6738, 8, 315, 10, + 315, 12, 315, 6741, 9, 315, 1, 316, 1, 316, 1, 316, 5, 316, 6746, 8, 316, + 10, 316, 12, 316, 6749, 9, 316, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, + 1, 317, 1, 317, 1, 317, 1, 317, 3, 317, 6760, 8, 317, 1, 317, 1, 317, 1, + 317, 1, 317, 1, 317, 3, 317, 6767, 8, 317, 1, 317, 1, 317, 1, 317, 1, 317, + 1, 317, 1, 317, 1, 317, 1, 317, 3, 317, 6777, 8, 317, 1, 318, 1, 318, 1, + 318, 3, 318, 6782, 8, 318, 1, 318, 3, 318, 6785, 8, 318, 1, 318, 1, 318, + 1, 318, 3, 318, 6790, 8, 318, 1, 318, 3, 318, 6793, 8, 318, 1, 319, 1, + 319, 3, 319, 6797, 8, 319, 1, 320, 1, 320, 1, 320, 1, 321, 1, 321, 1, 321, + 1, 321, 1, 322, 1, 322, 1, 322, 1, 323, 1, 323, 1, 323, 3, 323, 6812, 8, + 323, 1, 324, 1, 324, 1, 324, 1, 324, 1, 324, 1, 324, 3, 324, 6820, 8, 324, + 1, 324, 1, 324, 1, 324, 1, 324, 1, 324, 3, 324, 6827, 8, 324, 1, 324, 1, + 324, 1, 324, 3, 324, 6832, 8, 324, 1, 325, 1, 325, 1, 325, 3, 325, 6837, + 8, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, + 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, + 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, + 1, 325, 1, 325, 1, 325, 1, 325, 4, 325, 6869, 8, 325, 11, 325, 12, 325, + 6870, 1, 325, 1, 325, 3, 325, 6875, 8, 325, 1, 325, 1, 325, 1, 325, 1, + 325, 4, 325, 6881, 8, 325, 11, 325, 12, 325, 6882, 1, 325, 1, 325, 3, 325, + 6887, 8, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 3, + 325, 6896, 8, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 3, 325, + 6904, 8, 325, 1, 325, 1, 325, 1, 325, 3, 325, 6909, 8, 325, 1, 325, 1, + 325, 1, 325, 1, 325, 1, 325, 1, 325, 3, 325, 6917, 8, 325, 1, 325, 1, 325, + 1, 325, 3, 325, 6922, 8, 325, 1, 325, 1, 325, 1, 325, 3, 325, 6927, 8, + 325, 3, 325, 6929, 8, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, + 1, 325, 3, 325, 6938, 8, 325, 1, 325, 1, 325, 1, 325, 3, 325, 6943, 8, + 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 3, 325, 6951, 8, 325, + 1, 325, 1, 325, 1, 325, 3, 325, 6956, 8, 325, 1, 325, 1, 325, 1, 325, 1, + 325, 1, 325, 1, 325, 3, 325, 6964, 8, 325, 1, 325, 1, 325, 1, 325, 1, 325, + 1, 325, 1, 325, 3, 325, 6972, 8, 325, 1, 325, 3, 325, 6975, 8, 325, 1, + 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 3, 325, 6985, + 8, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, + 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 3, 325, + 7003, 8, 325, 1, 325, 3, 325, 7006, 8, 325, 1, 325, 3, 325, 7009, 8, 325, + 1, 325, 1, 325, 3, 325, 7013, 8, 325, 1, 326, 1, 326, 1, 326, 1, 326, 1, + 326, 1, 327, 1, 327, 1, 327, 1, 327, 5, 327, 7024, 8, 327, 10, 327, 12, + 327, 7027, 9, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 3, 327, 7034, + 8, 327, 1, 328, 1, 328, 3, 328, 7038, 8, 328, 1, 329, 1, 329, 1, 329, 3, + 329, 7043, 8, 329, 1, 329, 1, 329, 1, 329, 3, 329, 7048, 8, 329, 1, 329, + 1, 329, 1, 329, 1, 329, 3, 329, 7054, 8, 329, 1, 329, 1, 329, 1, 329, 3, + 329, 7059, 8, 329, 1, 329, 1, 329, 3, 329, 7063, 8, 329, 1, 329, 1, 329, + 1, 329, 3, 329, 7068, 8, 329, 1, 329, 1, 329, 1, 329, 3, 329, 7073, 8, + 329, 1, 329, 1, 329, 1, 329, 3, 329, 7078, 8, 329, 1, 329, 1, 329, 1, 329, + 1, 329, 1, 329, 1, 329, 5, 329, 7086, 8, 329, 10, 329, 12, 329, 7089, 9, + 329, 3, 329, 7091, 8, 329, 1, 329, 1, 329, 3, 329, 7095, 8, 329, 1, 329, + 1, 329, 3, 329, 7099, 8, 329, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 3, + 330, 7106, 8, 330, 1, 330, 1, 330, 3, 330, 7110, 8, 330, 1, 330, 1, 330, + 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, + 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, + 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 3, 330, 7139, 8, + 330, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 3, 331, 7147, 8, 331, + 1, 332, 3, 332, 7150, 8, 332, 1, 332, 3, 332, 7153, 8, 332, 1, 332, 3, + 332, 7156, 8, 332, 1, 332, 3, 332, 7159, 8, 332, 1, 333, 1, 333, 1, 334, + 1, 334, 1, 334, 1, 335, 1, 335, 1, 336, 1, 336, 3, 336, 7170, 8, 336, 1, + 337, 1, 337, 1, 337, 1, 337, 1, 337, 1, 338, 1, 338, 1, 338, 1, 338, 1, + 338, 1, 338, 1, 338, 3, 338, 7184, 8, 338, 1, 339, 1, 339, 1, 339, 1, 339, + 1, 339, 5, 339, 7191, 8, 339, 10, 339, 12, 339, 7194, 9, 339, 1, 340, 1, + 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, + 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, + 340, 1, 340, 1, 340, 1, 340, 1, 340, 3, 340, 7220, 8, 340, 1, 341, 1, 341, + 1, 341, 1, 341, 1, 341, 1, 342, 1, 342, 1, 342, 1, 342, 3, 342, 7231, 8, + 342, 1, 342, 1, 342, 1, 342, 1, 342, 1, 342, 3, 342, 7238, 8, 342, 5, 342, + 7240, 8, 342, 10, 342, 12, 342, 7243, 9, 342, 1, 343, 1, 343, 1, 343, 1, + 343, 3, 343, 7249, 8, 343, 1, 344, 1, 344, 1, 344, 1, 344, 1, 344, 1, 344, + 3, 344, 7257, 8, 344, 1, 344, 1, 344, 1, 344, 3, 344, 7262, 8, 344, 1, + 344, 1, 344, 1, 344, 1, 344, 5, 344, 7268, 8, 344, 10, 344, 12, 344, 7271, + 9, 344, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, + 1, 345, 3, 345, 7282, 8, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, + 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7295, 8, 345, 1, 345, + 1, 345, 1, 345, 1, 345, 3, 345, 7301, 8, 345, 1, 345, 1, 345, 1, 345, 1, + 345, 3, 345, 7307, 8, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, + 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 3, 345, + 7323, 8, 345, 1, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7329, 8, 345, 1, + 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 5, 345, 7338, 8, 345, + 10, 345, 12, 345, 7341, 9, 345, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, + 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, + 1, 346, 1, 346, 1, 346, 5, 346, 7360, 8, 346, 10, 346, 12, 346, 7363, 9, + 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 4, 346, 7372, + 8, 346, 11, 346, 12, 346, 7373, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, + 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, + 1, 346, 3, 346, 7391, 8, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, + 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, + 346, 1, 346, 1, 346, 1, 346, 1, 346, 5, 346, 7412, 8, 346, 10, 346, 12, + 346, 7415, 9, 346, 1, 347, 1, 347, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, + 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, + 3, 348, 7433, 8, 348, 1, 349, 1, 349, 1, 349, 1, 349, 1, 349, 1, 349, 1, + 349, 3, 349, 7442, 8, 349, 1, 350, 1, 350, 1, 350, 1, 350, 1, 350, 1, 350, + 1, 350, 3, 350, 7451, 8, 350, 1, 351, 1, 351, 1, 352, 1, 352, 1, 353, 1, + 353, 1, 353, 1, 353, 1, 353, 3, 353, 7462, 8, 353, 1, 354, 1, 354, 1, 355, + 1, 355, 1, 356, 1, 356, 1, 357, 1, 357, 1, 358, 1, 358, 1, 359, 1, 359, + 1, 360, 1, 360, 1, 360, 0, 3, 688, 690, 692, 361, 0, 2, 4, 6, 8, 10, 12, + 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, + 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, + 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, + 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, + 148, 150, 152, 154, 156, 158, 160, 162, 164, 166, 168, 170, 172, 174, 176, + 178, 180, 182, 184, 186, 188, 190, 192, 194, 196, 198, 200, 202, 204, 206, + 208, 210, 212, 214, 216, 218, 220, 222, 224, 226, 228, 230, 232, 234, 236, + 238, 240, 242, 244, 246, 248, 250, 252, 254, 256, 258, 260, 262, 264, 266, + 268, 270, 272, 274, 276, 278, 280, 282, 284, 286, 288, 290, 292, 294, 296, + 298, 300, 302, 304, 306, 308, 310, 312, 314, 316, 318, 320, 322, 324, 326, + 328, 330, 332, 334, 336, 338, 340, 342, 344, 346, 348, 350, 352, 354, 356, + 358, 360, 362, 364, 366, 368, 370, 372, 374, 376, 378, 380, 382, 384, 386, + 388, 390, 392, 394, 396, 398, 400, 402, 404, 406, 408, 410, 412, 414, 416, + 418, 420, 422, 424, 426, 428, 430, 432, 434, 436, 438, 440, 442, 444, 446, + 448, 450, 452, 454, 456, 458, 460, 462, 464, 466, 468, 470, 472, 474, 476, + 478, 480, 482, 484, 486, 488, 490, 492, 494, 496, 498, 500, 502, 504, 506, + 508, 510, 512, 514, 516, 518, 520, 522, 524, 526, 528, 530, 532, 534, 536, + 538, 540, 542, 544, 546, 548, 550, 552, 554, 556, 558, 560, 562, 564, 566, + 568, 570, 572, 574, 576, 578, 580, 582, 584, 586, 588, 590, 592, 594, 596, + 598, 600, 602, 604, 606, 608, 610, 612, 614, 616, 618, 620, 622, 624, 626, + 628, 630, 632, 634, 636, 638, 640, 642, 644, 646, 648, 650, 652, 654, 656, + 658, 660, 662, 664, 666, 668, 670, 672, 674, 676, 678, 680, 682, 684, 686, + 688, 690, 692, 694, 696, 698, 700, 702, 704, 706, 708, 710, 712, 714, 716, + 718, 720, 0, 144, 2, 0, 39, 39, 150, 150, 2, 0, 532, 532, 538, 538, 3, + 0, 69, 69, 159, 159, 181, 181, 3, 0, 42, 42, 385, 385, 455, 455, 4, 0, + 42, 42, 420, 420, 530, 530, 612, 612, 2, 0, 515, 515, 1153, 1153, 2, 0, + 78, 78, 141, 141, 2, 0, 15, 15, 335, 335, 3, 0, 44, 44, 85, 85, 184, 184, + 2, 0, 435, 435, 559, 559, 3, 0, 507, 507, 651, 651, 659, 659, 2, 0, 393, + 393, 461, 461, 2, 0, 353, 353, 475, 475, 2, 0, 42, 42, 1143, 1144, 2, 0, + 351, 351, 444, 444, 2, 0, 460, 460, 674, 674, 3, 0, 80, 80, 84, 84, 125, + 125, 3, 0, 42, 42, 403, 403, 432, 432, 3, 0, 42, 42, 399, 399, 793, 793, + 2, 0, 638, 638, 673, 673, 2, 0, 81, 81, 91, 91, 3, 0, 437, 437, 549, 549, + 614, 614, 2, 0, 69, 69, 159, 159, 1, 0, 357, 358, 1, 0, 1143, 1144, 2, + 0, 1153, 1153, 1161, 1161, 2, 0, 81, 81, 389, 389, 2, 0, 546, 546, 1153, + 1153, 2, 0, 547, 547, 1153, 1153, 3, 0, 431, 431, 470, 470, 522, 522, 7, + 0, 42, 42, 371, 371, 373, 373, 403, 403, 432, 432, 574, 574, 1161, 1161, + 2, 0, 515, 515, 531, 531, 1, 0, 1144, 1145, 2, 0, 5, 5, 51, 51, 4, 0, 42, + 42, 385, 385, 455, 455, 459, 459, 2, 0, 26, 26, 30, 30, 2, 0, 12, 12, 175, + 175, 2, 0, 192, 192, 678, 678, 2, 0, 21, 21, 144, 144, 3, 0, 43, 43, 75, + 75, 106, 106, 2, 0, 106, 106, 375, 375, 2, 0, 366, 366, 428, 428, 2, 0, + 101, 101, 602, 602, 2, 0, 43, 43, 106, 106, 2, 0, 6, 6, 49, 49, 2, 0, 188, + 188, 670, 670, 4, 0, 431, 431, 470, 470, 521, 521, 563, 563, 2, 0, 431, + 431, 521, 521, 2, 0, 13, 13, 45, 45, 3, 0, 66, 66, 78, 78, 186, 186, 2, + 0, 34, 34, 83, 83, 2, 0, 97, 97, 148, 148, 2, 0, 6, 6, 49, 50, 1, 0, 627, + 628, 2, 0, 172, 172, 743, 743, 2, 0, 440, 440, 610, 610, 2, 0, 226, 226, + 478, 478, 5, 0, 107, 107, 483, 484, 486, 486, 490, 498, 576, 576, 4, 0, + 480, 481, 485, 485, 487, 488, 577, 577, 3, 0, 108, 108, 479, 479, 489, + 489, 2, 0, 463, 463, 629, 629, 2, 0, 623, 623, 625, 625, 2, 0, 345, 345, + 630, 630, 2, 0, 90, 90, 592, 592, 2, 0, 51, 51, 391, 391, 3, 0, 31, 31, + 61, 61, 179, 179, 3, 0, 131, 131, 172, 172, 438, 438, 3, 0, 12, 12, 19, + 19, 187, 187, 2, 0, 42, 42, 121, 121, 2, 0, 103, 103, 182, 182, 2, 0, 361, + 361, 615, 615, 2, 0, 40, 40, 672, 672, 2, 0, 115, 115, 475, 475, 2, 0, + 423, 423, 569, 569, 4, 0, 206, 206, 208, 208, 214, 214, 639, 639, 2, 0, + 1113, 1113, 1129, 1129, 2, 0, 346, 346, 578, 578, 2, 0, 68, 68, 80, 80, + 6, 0, 131, 131, 172, 172, 177, 177, 416, 416, 438, 438, 672, 672, 2, 0, + 514, 514, 635, 635, 2, 0, 413, 413, 676, 676, 2, 0, 131, 131, 438, 438, + 3, 0, 81, 81, 92, 92, 453, 453, 3, 0, 440, 440, 475, 475, 610, 610, 2, + 0, 635, 635, 671, 671, 2, 0, 377, 377, 568, 568, 6, 0, 226, 226, 410, 410, + 412, 412, 439, 439, 575, 575, 616, 616, 2, 0, 45, 46, 62, 62, 3, 0, 423, + 423, 551, 551, 887, 887, 2, 0, 467, 467, 653, 653, 10, 0, 360, 360, 368, + 368, 379, 381, 388, 388, 508, 508, 516, 516, 640, 640, 647, 647, 837, 837, + 1007, 1007, 2, 0, 35, 35, 168, 168, 2, 0, 117, 117, 998, 998, 11, 0, 360, + 360, 368, 368, 379, 381, 388, 388, 508, 508, 516, 516, 593, 593, 640, 640, + 647, 647, 837, 837, 1007, 1007, 2, 0, 1142, 1142, 1163, 1164, 1, 0, 1164, + 1165, 2, 0, 376, 376, 788, 799, 3, 0, 1143, 1145, 1154, 1154, 1156, 1156, + 2, 0, 63, 63, 178, 178, 2, 0, 116, 116, 1157, 1157, 5, 0, 25, 25, 222, + 224, 231, 231, 233, 236, 519, 519, 2, 0, 25, 25, 222, 222, 2, 0, 25, 25, + 222, 223, 1, 0, 196, 207, 3, 0, 183, 183, 195, 195, 613, 613, 2, 0, 211, + 216, 432, 432, 6, 0, 217, 217, 228, 228, 230, 230, 232, 232, 239, 239, + 349, 350, 5, 0, 218, 221, 226, 227, 229, 229, 240, 240, 347, 347, 2, 0, + 153, 153, 237, 237, 2, 0, 467, 467, 804, 812, 3, 0, 211, 211, 226, 226, + 519, 519, 6, 0, 200, 200, 206, 206, 209, 209, 217, 218, 220, 221, 467, + 467, 1, 0, 214, 215, 2, 0, 183, 183, 613, 613, 2, 0, 200, 200, 206, 206, + 2, 0, 316, 317, 323, 323, 3, 0, 150, 150, 314, 317, 332, 332, 1, 0, 326, + 327, 3, 0, 17, 17, 95, 95, 176, 176, 2, 0, 222, 222, 226, 226, 2, 0, 217, + 218, 220, 220, 3, 0, 13, 13, 45, 45, 996, 996, 3, 0, 287, 287, 299, 300, + 310, 310, 3, 0, 288, 290, 306, 309, 311, 313, 2, 0, 296, 296, 298, 298, + 2, 0, 294, 294, 297, 297, 2, 0, 292, 293, 303, 305, 2, 0, 133, 133, 602, + 602, 2, 0, 434, 434, 560, 560, 2, 0, 536, 536, 552, 552, 2, 0, 114, 114, + 1132, 1132, 3, 0, 63, 63, 178, 178, 663, 663, 2, 0, 137, 137, 149, 149, + 3, 0, 6, 6, 338, 338, 619, 619, 3, 0, 114, 114, 1125, 1126, 1132, 1133, + 2, 0, 1122, 1124, 1127, 1128, 1, 0, 1125, 1126, 2, 0, 226, 226, 747, 787, + 1, 0, 800, 803, 5, 0, 709, 710, 726, 728, 734, 734, 740, 741, 743, 743, + 1, 0, 690, 697, 3, 0, 217, 221, 234, 234, 237, 237, 57, 0, 11, 11, 14, + 14, 18, 18, 29, 29, 35, 35, 37, 37, 42, 42, 48, 48, 55, 55, 57, 57, 59, + 59, 73, 73, 79, 79, 94, 94, 117, 117, 121, 121, 124, 124, 130, 130, 158, + 158, 168, 168, 239, 239, 284, 291, 295, 295, 299, 300, 306, 313, 333, 386, + 388, 404, 406, 406, 408, 433, 435, 451, 453, 459, 461, 522, 524, 524, 528, + 545, 548, 559, 561, 590, 592, 607, 609, 637, 639, 673, 675, 676, 678, 689, + 698, 698, 700, 708, 711, 713, 718, 719, 721, 725, 729, 733, 735, 735, 737, + 739, 742, 742, 744, 746, 793, 793, 837, 837, 877, 877, 1002, 1002, 1007, + 1007, 1091, 1091, 24, 0, 39, 39, 97, 97, 148, 148, 150, 150, 170, 170, + 217, 219, 221, 221, 252, 283, 291, 294, 296, 298, 301, 305, 325, 325, 460, + 460, 674, 674, 690, 697, 737, 737, 804, 804, 807, 836, 838, 876, 878, 1001, + 1003, 1006, 1008, 1090, 1092, 1112, 1128, 1128, 8807, 0, 723, 1, 0, 0, + 0, 2, 742, 1, 0, 0, 0, 4, 763, 1, 0, 0, 0, 6, 765, 1, 0, 0, 0, 8, 805, + 1, 0, 0, 0, 10, 820, 1, 0, 0, 0, 12, 831, 1, 0, 0, 0, 14, 848, 1, 0, 0, + 0, 16, 853, 1, 0, 0, 0, 18, 868, 1, 0, 0, 0, 20, 895, 1, 0, 0, 0, 22, 904, + 1, 0, 0, 0, 24, 906, 1, 0, 0, 0, 26, 918, 1, 0, 0, 0, 28, 948, 1, 0, 0, + 0, 30, 984, 1, 0, 0, 0, 32, 1035, 1, 0, 0, 0, 34, 1061, 1, 0, 0, 0, 36, + 1097, 1, 0, 0, 0, 38, 1110, 1, 0, 0, 0, 40, 1207, 1, 0, 0, 0, 42, 1209, + 1, 0, 0, 0, 44, 1227, 1, 0, 0, 0, 46, 1288, 1, 0, 0, 0, 48, 1310, 1, 0, + 0, 0, 50, 1316, 1, 0, 0, 0, 52, 1338, 1, 0, 0, 0, 54, 1340, 1, 0, 0, 0, + 56, 1342, 1, 0, 0, 0, 58, 1422, 1, 0, 0, 0, 60, 1429, 1, 0, 0, 0, 62, 1431, + 1, 0, 0, 0, 64, 1436, 1, 0, 0, 0, 66, 1476, 1, 0, 0, 0, 68, 1482, 1, 0, + 0, 0, 70, 1484, 1, 0, 0, 0, 72, 1505, 1, 0, 0, 0, 74, 1512, 1, 0, 0, 0, + 76, 1514, 1, 0, 0, 0, 78, 1539, 1, 0, 0, 0, 80, 1542, 1, 0, 0, 0, 82, 1547, + 1, 0, 0, 0, 84, 1573, 1, 0, 0, 0, 86, 1589, 1, 0, 0, 0, 88, 1591, 1, 0, + 0, 0, 90, 1613, 1, 0, 0, 0, 92, 1615, 1, 0, 0, 0, 94, 1681, 1, 0, 0, 0, + 96, 1752, 1, 0, 0, 0, 98, 1754, 1, 0, 0, 0, 100, 1782, 1, 0, 0, 0, 102, + 1792, 1, 0, 0, 0, 104, 1822, 1, 0, 0, 0, 106, 2009, 1, 0, 0, 0, 108, 2011, + 1, 0, 0, 0, 110, 2013, 1, 0, 0, 0, 112, 2016, 1, 0, 0, 0, 114, 2091, 1, + 0, 0, 0, 116, 2114, 1, 0, 0, 0, 118, 2262, 1, 0, 0, 0, 120, 2267, 1, 0, + 0, 0, 122, 2269, 1, 0, 0, 0, 124, 2279, 1, 0, 0, 0, 126, 2335, 1, 0, 0, + 0, 128, 2355, 1, 0, 0, 0, 130, 2357, 1, 0, 0, 0, 132, 2392, 1, 0, 0, 0, + 134, 2401, 1, 0, 0, 0, 136, 2408, 1, 0, 0, 0, 138, 2431, 1, 0, 0, 0, 140, + 2440, 1, 0, 0, 0, 142, 2455, 1, 0, 0, 0, 144, 2480, 1, 0, 0, 0, 146, 2500, + 1, 0, 0, 0, 148, 2883, 1, 0, 0, 0, 150, 2983, 1, 0, 0, 0, 152, 2985, 1, + 0, 0, 0, 154, 2992, 1, 0, 0, 0, 156, 2999, 1, 0, 0, 0, 158, 3022, 1, 0, + 0, 0, 160, 3030, 1, 0, 0, 0, 162, 3037, 1, 0, 0, 0, 164, 3044, 1, 0, 0, + 0, 166, 3051, 1, 0, 0, 0, 168, 3063, 1, 0, 0, 0, 170, 3073, 1, 0, 0, 0, + 172, 3080, 1, 0, 0, 0, 174, 3096, 1, 0, 0, 0, 176, 3142, 1, 0, 0, 0, 178, + 3144, 1, 0, 0, 0, 180, 3154, 1, 0, 0, 0, 182, 3158, 1, 0, 0, 0, 184, 3164, + 1, 0, 0, 0, 186, 3176, 1, 0, 0, 0, 188, 3178, 1, 0, 0, 0, 190, 3185, 1, + 0, 0, 0, 192, 3187, 1, 0, 0, 0, 194, 3245, 1, 0, 0, 0, 196, 3319, 1, 0, + 0, 0, 198, 3378, 1, 0, 0, 0, 200, 3476, 1, 0, 0, 0, 202, 3480, 1, 0, 0, + 0, 204, 3482, 1, 0, 0, 0, 206, 3517, 1, 0, 0, 0, 208, 3519, 1, 0, 0, 0, + 210, 3527, 1, 0, 0, 0, 212, 3535, 1, 0, 0, 0, 214, 3537, 1, 0, 0, 0, 216, + 3573, 1, 0, 0, 0, 218, 3628, 1, 0, 0, 0, 220, 3637, 1, 0, 0, 0, 222, 3657, + 1, 0, 0, 0, 224, 3669, 1, 0, 0, 0, 226, 3673, 1, 0, 0, 0, 228, 3706, 1, + 0, 0, 0, 230, 3727, 1, 0, 0, 0, 232, 3737, 1, 0, 0, 0, 234, 3741, 1, 0, + 0, 0, 236, 3767, 1, 0, 0, 0, 238, 3809, 1, 0, 0, 0, 240, 3811, 1, 0, 0, + 0, 242, 3826, 1, 0, 0, 0, 244, 3875, 1, 0, 0, 0, 246, 3884, 1, 0, 0, 0, + 248, 3894, 1, 0, 0, 0, 250, 3904, 1, 0, 0, 0, 252, 3960, 1, 0, 0, 0, 254, + 3962, 1, 0, 0, 0, 256, 3989, 1, 0, 0, 0, 258, 3995, 1, 0, 0, 0, 260, 4003, + 1, 0, 0, 0, 262, 4020, 1, 0, 0, 0, 264, 4036, 1, 0, 0, 0, 266, 4073, 1, + 0, 0, 0, 268, 4079, 1, 0, 0, 0, 270, 4088, 1, 0, 0, 0, 272, 4101, 1, 0, + 0, 0, 274, 4105, 1, 0, 0, 0, 276, 4143, 1, 0, 0, 0, 278, 4181, 1, 0, 0, + 0, 280, 4195, 1, 0, 0, 0, 282, 4203, 1, 0, 0, 0, 284, 4207, 1, 0, 0, 0, + 286, 4213, 1, 0, 0, 0, 288, 4227, 1, 0, 0, 0, 290, 4230, 1, 0, 0, 0, 292, + 4248, 1, 0, 0, 0, 294, 4252, 1, 0, 0, 0, 296, 4268, 1, 0, 0, 0, 298, 4270, + 1, 0, 0, 0, 300, 4282, 1, 0, 0, 0, 302, 4286, 1, 0, 0, 0, 304, 4303, 1, + 0, 0, 0, 306, 4320, 1, 0, 0, 0, 308, 4323, 1, 0, 0, 0, 310, 4333, 1, 0, + 0, 0, 312, 4337, 1, 0, 0, 0, 314, 4350, 1, 0, 0, 0, 316, 4353, 1, 0, 0, + 0, 318, 4358, 1, 0, 0, 0, 320, 4378, 1, 0, 0, 0, 322, 4380, 1, 0, 0, 0, + 324, 4397, 1, 0, 0, 0, 326, 4406, 1, 0, 0, 0, 328, 4415, 1, 0, 0, 0, 330, + 4417, 1, 0, 0, 0, 332, 4431, 1, 0, 0, 0, 334, 4442, 1, 0, 0, 0, 336, 4451, + 1, 0, 0, 0, 338, 4454, 1, 0, 0, 0, 340, 4462, 1, 0, 0, 0, 342, 4487, 1, + 0, 0, 0, 344, 4499, 1, 0, 0, 0, 346, 4502, 1, 0, 0, 0, 348, 4534, 1, 0, + 0, 0, 350, 4536, 1, 0, 0, 0, 352, 4538, 1, 0, 0, 0, 354, 4540, 1, 0, 0, + 0, 356, 4542, 1, 0, 0, 0, 358, 4595, 1, 0, 0, 0, 360, 4597, 1, 0, 0, 0, + 362, 4603, 1, 0, 0, 0, 364, 4623, 1, 0, 0, 0, 366, 4637, 1, 0, 0, 0, 368, + 4648, 1, 0, 0, 0, 370, 4650, 1, 0, 0, 0, 372, 4656, 1, 0, 0, 0, 374, 4666, + 1, 0, 0, 0, 376, 4670, 1, 0, 0, 0, 378, 4677, 1, 0, 0, 0, 380, 4681, 1, + 0, 0, 0, 382, 4687, 1, 0, 0, 0, 384, 4694, 1, 0, 0, 0, 386, 4700, 1, 0, + 0, 0, 388, 4706, 1, 0, 0, 0, 390, 4711, 1, 0, 0, 0, 392, 4756, 1, 0, 0, + 0, 394, 4777, 1, 0, 0, 0, 396, 4802, 1, 0, 0, 0, 398, 4805, 1, 0, 0, 0, + 400, 4811, 1, 0, 0, 0, 402, 4827, 1, 0, 0, 0, 404, 4842, 1, 0, 0, 0, 406, + 4848, 1, 0, 0, 0, 408, 4878, 1, 0, 0, 0, 410, 4880, 1, 0, 0, 0, 412, 4887, + 1, 0, 0, 0, 414, 4899, 1, 0, 0, 0, 416, 4905, 1, 0, 0, 0, 418, 4930, 1, + 0, 0, 0, 420, 4934, 1, 0, 0, 0, 422, 4938, 1, 0, 0, 0, 424, 4949, 1, 0, + 0, 0, 426, 5030, 1, 0, 0, 0, 428, 5097, 1, 0, 0, 0, 430, 5099, 1, 0, 0, + 0, 432, 5205, 1, 0, 0, 0, 434, 5229, 1, 0, 0, 0, 436, 5231, 1, 0, 0, 0, + 438, 5249, 1, 0, 0, 0, 440, 5357, 1, 0, 0, 0, 442, 5359, 1, 0, 0, 0, 444, + 5372, 1, 0, 0, 0, 446, 5383, 1, 0, 0, 0, 448, 5411, 1, 0, 0, 0, 450, 5415, + 1, 0, 0, 0, 452, 5436, 1, 0, 0, 0, 454, 5446, 1, 0, 0, 0, 456, 5456, 1, + 0, 0, 0, 458, 5496, 1, 0, 0, 0, 460, 5498, 1, 0, 0, 0, 462, 5501, 1, 0, + 0, 0, 464, 5601, 1, 0, 0, 0, 466, 5619, 1, 0, 0, 0, 468, 5621, 1, 0, 0, + 0, 470, 5625, 1, 0, 0, 0, 472, 5663, 1, 0, 0, 0, 474, 5672, 1, 0, 0, 0, + 476, 5678, 1, 0, 0, 0, 478, 5685, 1, 0, 0, 0, 480, 5707, 1, 0, 0, 0, 482, + 5709, 1, 0, 0, 0, 484, 5723, 1, 0, 0, 0, 486, 5729, 1, 0, 0, 0, 488, 5785, + 1, 0, 0, 0, 490, 5940, 1, 0, 0, 0, 492, 5952, 1, 0, 0, 0, 494, 5967, 1, + 0, 0, 0, 496, 5973, 1, 0, 0, 0, 498, 5992, 1, 0, 0, 0, 500, 6002, 1, 0, + 0, 0, 502, 6016, 1, 0, 0, 0, 504, 6018, 1, 0, 0, 0, 506, 6021, 1, 0, 0, + 0, 508, 6043, 1, 0, 0, 0, 510, 6055, 1, 0, 0, 0, 512, 6061, 1, 0, 0, 0, + 514, 6073, 1, 0, 0, 0, 516, 6077, 1, 0, 0, 0, 518, 6079, 1, 0, 0, 0, 520, + 6121, 1, 0, 0, 0, 522, 6128, 1, 0, 0, 0, 524, 6130, 1, 0, 0, 0, 526, 6153, + 1, 0, 0, 0, 528, 6159, 1, 0, 0, 0, 530, 6167, 1, 0, 0, 0, 532, 6170, 1, + 0, 0, 0, 534, 6173, 1, 0, 0, 0, 536, 6194, 1, 0, 0, 0, 538, 6215, 1, 0, + 0, 0, 540, 6223, 1, 0, 0, 0, 542, 6235, 1, 0, 0, 0, 544, 6243, 1, 0, 0, + 0, 546, 6281, 1, 0, 0, 0, 548, 6293, 1, 0, 0, 0, 550, 6295, 1, 0, 0, 0, + 552, 6301, 1, 0, 0, 0, 554, 6305, 1, 0, 0, 0, 556, 6321, 1, 0, 0, 0, 558, + 6334, 1, 0, 0, 0, 560, 6343, 1, 0, 0, 0, 562, 6345, 1, 0, 0, 0, 564, 6352, + 1, 0, 0, 0, 566, 6354, 1, 0, 0, 0, 568, 6360, 1, 0, 0, 0, 570, 6364, 1, + 0, 0, 0, 572, 6369, 1, 0, 0, 0, 574, 6371, 1, 0, 0, 0, 576, 6373, 1, 0, + 0, 0, 578, 6391, 1, 0, 0, 0, 580, 6407, 1, 0, 0, 0, 582, 6411, 1, 0, 0, + 0, 584, 6416, 1, 0, 0, 0, 586, 6427, 1, 0, 0, 0, 588, 6432, 1, 0, 0, 0, + 590, 6434, 1, 0, 0, 0, 592, 6438, 1, 0, 0, 0, 594, 6463, 1, 0, 0, 0, 596, + 6465, 1, 0, 0, 0, 598, 6468, 1, 0, 0, 0, 600, 6473, 1, 0, 0, 0, 602, 6489, + 1, 0, 0, 0, 604, 6617, 1, 0, 0, 0, 606, 6619, 1, 0, 0, 0, 608, 6652, 1, + 0, 0, 0, 610, 6657, 1, 0, 0, 0, 612, 6661, 1, 0, 0, 0, 614, 6667, 1, 0, + 0, 0, 616, 6675, 1, 0, 0, 0, 618, 6683, 1, 0, 0, 0, 620, 6691, 1, 0, 0, + 0, 622, 6699, 1, 0, 0, 0, 624, 6710, 1, 0, 0, 0, 626, 6718, 1, 0, 0, 0, + 628, 6726, 1, 0, 0, 0, 630, 6734, 1, 0, 0, 0, 632, 6742, 1, 0, 0, 0, 634, + 6776, 1, 0, 0, 0, 636, 6792, 1, 0, 0, 0, 638, 6796, 1, 0, 0, 0, 640, 6798, + 1, 0, 0, 0, 642, 6801, 1, 0, 0, 0, 644, 6805, 1, 0, 0, 0, 646, 6811, 1, + 0, 0, 0, 648, 6831, 1, 0, 0, 0, 650, 7012, 1, 0, 0, 0, 652, 7014, 1, 0, + 0, 0, 654, 7033, 1, 0, 0, 0, 656, 7035, 1, 0, 0, 0, 658, 7098, 1, 0, 0, + 0, 660, 7138, 1, 0, 0, 0, 662, 7140, 1, 0, 0, 0, 664, 7149, 1, 0, 0, 0, + 666, 7160, 1, 0, 0, 0, 668, 7162, 1, 0, 0, 0, 670, 7165, 1, 0, 0, 0, 672, + 7169, 1, 0, 0, 0, 674, 7171, 1, 0, 0, 0, 676, 7183, 1, 0, 0, 0, 678, 7185, + 1, 0, 0, 0, 680, 7219, 1, 0, 0, 0, 682, 7221, 1, 0, 0, 0, 684, 7230, 1, + 0, 0, 0, 686, 7248, 1, 0, 0, 0, 688, 7261, 1, 0, 0, 0, 690, 7272, 1, 0, + 0, 0, 692, 7390, 1, 0, 0, 0, 694, 7416, 1, 0, 0, 0, 696, 7432, 1, 0, 0, + 0, 698, 7441, 1, 0, 0, 0, 700, 7450, 1, 0, 0, 0, 702, 7452, 1, 0, 0, 0, + 704, 7454, 1, 0, 0, 0, 706, 7461, 1, 0, 0, 0, 708, 7463, 1, 0, 0, 0, 710, + 7465, 1, 0, 0, 0, 712, 7467, 1, 0, 0, 0, 714, 7469, 1, 0, 0, 0, 716, 7471, + 1, 0, 0, 0, 718, 7473, 1, 0, 0, 0, 720, 7475, 1, 0, 0, 0, 722, 724, 3, + 2, 1, 0, 723, 722, 1, 0, 0, 0, 723, 724, 1, 0, 0, 0, 724, 727, 1, 0, 0, + 0, 725, 726, 5, 1126, 0, 0, 726, 728, 5, 1126, 0, 0, 727, 725, 1, 0, 0, + 0, 727, 728, 1, 0, 0, 0, 728, 729, 1, 0, 0, 0, 729, 730, 5, 0, 0, 1, 730, + 1, 1, 0, 0, 0, 731, 734, 3, 4, 2, 0, 732, 733, 5, 1126, 0, 0, 733, 735, + 5, 1126, 0, 0, 734, 732, 1, 0, 0, 0, 734, 735, 1, 0, 0, 0, 735, 737, 1, + 0, 0, 0, 736, 738, 5, 1141, 0, 0, 737, 736, 1, 0, 0, 0, 737, 738, 1, 0, + 0, 0, 738, 741, 1, 0, 0, 0, 739, 741, 3, 6, 3, 0, 740, 731, 1, 0, 0, 0, + 740, 739, 1, 0, 0, 0, 741, 744, 1, 0, 0, 0, 742, 740, 1, 0, 0, 0, 742, + 743, 1, 0, 0, 0, 743, 754, 1, 0, 0, 0, 744, 742, 1, 0, 0, 0, 745, 751, + 3, 4, 2, 0, 746, 747, 5, 1126, 0, 0, 747, 749, 5, 1126, 0, 0, 748, 746, + 1, 0, 0, 0, 748, 749, 1, 0, 0, 0, 749, 750, 1, 0, 0, 0, 750, 752, 5, 1141, + 0, 0, 751, 748, 1, 0, 0, 0, 751, 752, 1, 0, 0, 0, 752, 755, 1, 0, 0, 0, + 753, 755, 3, 6, 3, 0, 754, 745, 1, 0, 0, 0, 754, 753, 1, 0, 0, 0, 755, + 3, 1, 0, 0, 0, 756, 764, 3, 8, 4, 0, 757, 764, 3, 10, 5, 0, 758, 764, 3, + 12, 6, 0, 759, 764, 3, 14, 7, 0, 760, 764, 3, 16, 8, 0, 761, 764, 3, 20, + 10, 0, 762, 764, 3, 22, 11, 0, 763, 756, 1, 0, 0, 0, 763, 757, 1, 0, 0, + 0, 763, 758, 1, 0, 0, 0, 763, 759, 1, 0, 0, 0, 763, 760, 1, 0, 0, 0, 763, + 761, 1, 0, 0, 0, 763, 762, 1, 0, 0, 0, 764, 5, 1, 0, 0, 0, 765, 766, 5, + 1141, 0, 0, 766, 7, 1, 0, 0, 0, 767, 806, 3, 24, 12, 0, 768, 806, 3, 26, + 13, 0, 769, 806, 3, 28, 14, 0, 770, 806, 3, 30, 15, 0, 771, 806, 3, 32, + 16, 0, 772, 806, 3, 34, 17, 0, 773, 806, 3, 38, 19, 0, 774, 806, 3, 40, + 20, 0, 775, 806, 3, 42, 21, 0, 776, 806, 3, 44, 22, 0, 777, 806, 3, 46, + 23, 0, 778, 806, 3, 56, 28, 0, 779, 806, 3, 36, 18, 0, 780, 806, 3, 128, + 64, 0, 781, 806, 3, 130, 65, 0, 782, 806, 3, 132, 66, 0, 783, 806, 3, 134, + 67, 0, 784, 806, 3, 136, 68, 0, 785, 806, 3, 138, 69, 0, 786, 806, 3, 140, + 70, 0, 787, 806, 3, 142, 71, 0, 788, 806, 3, 144, 72, 0, 789, 806, 3, 146, + 73, 0, 790, 806, 3, 152, 76, 0, 791, 806, 3, 154, 77, 0, 792, 806, 3, 156, + 78, 0, 793, 806, 3, 158, 79, 0, 794, 806, 3, 160, 80, 0, 795, 806, 3, 162, + 81, 0, 796, 806, 3, 164, 82, 0, 797, 806, 3, 166, 83, 0, 798, 806, 3, 168, + 84, 0, 799, 806, 3, 170, 85, 0, 800, 806, 3, 172, 86, 0, 801, 806, 3, 174, + 87, 0, 802, 806, 3, 176, 88, 0, 803, 806, 3, 178, 89, 0, 804, 806, 3, 182, + 91, 0, 805, 767, 1, 0, 0, 0, 805, 768, 1, 0, 0, 0, 805, 769, 1, 0, 0, 0, + 805, 770, 1, 0, 0, 0, 805, 771, 1, 0, 0, 0, 805, 772, 1, 0, 0, 0, 805, + 773, 1, 0, 0, 0, 805, 774, 1, 0, 0, 0, 805, 775, 1, 0, 0, 0, 805, 776, + 1, 0, 0, 0, 805, 777, 1, 0, 0, 0, 805, 778, 1, 0, 0, 0, 805, 779, 1, 0, + 0, 0, 805, 780, 1, 0, 0, 0, 805, 781, 1, 0, 0, 0, 805, 782, 1, 0, 0, 0, + 805, 783, 1, 0, 0, 0, 805, 784, 1, 0, 0, 0, 805, 785, 1, 0, 0, 0, 805, + 786, 1, 0, 0, 0, 805, 787, 1, 0, 0, 0, 805, 788, 1, 0, 0, 0, 805, 789, + 1, 0, 0, 0, 805, 790, 1, 0, 0, 0, 805, 791, 1, 0, 0, 0, 805, 792, 1, 0, + 0, 0, 805, 793, 1, 0, 0, 0, 805, 794, 1, 0, 0, 0, 805, 795, 1, 0, 0, 0, + 805, 796, 1, 0, 0, 0, 805, 797, 1, 0, 0, 0, 805, 798, 1, 0, 0, 0, 805, + 799, 1, 0, 0, 0, 805, 800, 1, 0, 0, 0, 805, 801, 1, 0, 0, 0, 805, 802, + 1, 0, 0, 0, 805, 803, 1, 0, 0, 0, 805, 804, 1, 0, 0, 0, 806, 9, 1, 0, 0, + 0, 807, 821, 3, 200, 100, 0, 808, 821, 3, 192, 96, 0, 809, 821, 3, 202, + 101, 0, 810, 821, 3, 186, 93, 0, 811, 821, 3, 198, 99, 0, 812, 821, 3, + 184, 92, 0, 813, 821, 3, 194, 97, 0, 814, 821, 3, 196, 98, 0, 815, 821, + 3, 188, 94, 0, 816, 821, 3, 190, 95, 0, 817, 821, 3, 204, 102, 0, 818, + 821, 3, 540, 270, 0, 819, 821, 3, 542, 271, 0, 820, 807, 1, 0, 0, 0, 820, + 808, 1, 0, 0, 0, 820, 809, 1, 0, 0, 0, 820, 810, 1, 0, 0, 0, 820, 811, + 1, 0, 0, 0, 820, 812, 1, 0, 0, 0, 820, 813, 1, 0, 0, 0, 820, 814, 1, 0, + 0, 0, 820, 815, 1, 0, 0, 0, 820, 816, 1, 0, 0, 0, 820, 817, 1, 0, 0, 0, + 820, 818, 1, 0, 0, 0, 820, 819, 1, 0, 0, 0, 821, 11, 1, 0, 0, 0, 822, 832, + 3, 298, 149, 0, 823, 832, 3, 300, 150, 0, 824, 832, 3, 302, 151, 0, 825, + 832, 3, 304, 152, 0, 826, 832, 3, 306, 153, 0, 827, 832, 3, 308, 154, 0, + 828, 832, 3, 310, 155, 0, 829, 832, 3, 312, 156, 0, 830, 832, 3, 314, 157, + 0, 831, 822, 1, 0, 0, 0, 831, 823, 1, 0, 0, 0, 831, 824, 1, 0, 0, 0, 831, + 825, 1, 0, 0, 0, 831, 826, 1, 0, 0, 0, 831, 827, 1, 0, 0, 0, 831, 828, + 1, 0, 0, 0, 831, 829, 1, 0, 0, 0, 831, 830, 1, 0, 0, 0, 832, 13, 1, 0, + 0, 0, 833, 849, 3, 330, 165, 0, 834, 849, 3, 332, 166, 0, 835, 849, 3, + 334, 167, 0, 836, 849, 3, 336, 168, 0, 837, 849, 3, 338, 169, 0, 838, 849, + 3, 340, 170, 0, 839, 849, 3, 342, 171, 0, 840, 849, 3, 344, 172, 0, 841, + 849, 3, 346, 173, 0, 842, 849, 3, 370, 185, 0, 843, 849, 3, 372, 186, 0, + 844, 849, 3, 374, 187, 0, 845, 849, 3, 376, 188, 0, 846, 849, 3, 378, 189, + 0, 847, 849, 3, 380, 190, 0, 848, 833, 1, 0, 0, 0, 848, 834, 1, 0, 0, 0, + 848, 835, 1, 0, 0, 0, 848, 836, 1, 0, 0, 0, 848, 837, 1, 0, 0, 0, 848, + 838, 1, 0, 0, 0, 848, 839, 1, 0, 0, 0, 848, 840, 1, 0, 0, 0, 848, 841, + 1, 0, 0, 0, 848, 842, 1, 0, 0, 0, 848, 843, 1, 0, 0, 0, 848, 844, 1, 0, + 0, 0, 848, 845, 1, 0, 0, 0, 848, 846, 1, 0, 0, 0, 848, 847, 1, 0, 0, 0, + 849, 15, 1, 0, 0, 0, 850, 854, 3, 382, 191, 0, 851, 854, 3, 384, 192, 0, + 852, 854, 3, 386, 193, 0, 853, 850, 1, 0, 0, 0, 853, 851, 1, 0, 0, 0, 853, + 852, 1, 0, 0, 0, 854, 17, 1, 0, 0, 0, 855, 869, 3, 390, 195, 0, 856, 869, + 3, 392, 196, 0, 857, 869, 3, 394, 197, 0, 858, 869, 3, 398, 199, 0, 859, + 869, 3, 400, 200, 0, 860, 869, 3, 402, 201, 0, 861, 869, 3, 406, 203, 0, + 862, 869, 3, 396, 198, 0, 863, 869, 3, 404, 202, 0, 864, 869, 3, 408, 204, + 0, 865, 866, 3, 540, 270, 0, 866, 867, 3, 10, 5, 0, 867, 869, 1, 0, 0, + 0, 868, 855, 1, 0, 0, 0, 868, 856, 1, 0, 0, 0, 868, 857, 1, 0, 0, 0, 868, + 858, 1, 0, 0, 0, 868, 859, 1, 0, 0, 0, 868, 860, 1, 0, 0, 0, 868, 861, + 1, 0, 0, 0, 868, 862, 1, 0, 0, 0, 868, 863, 1, 0, 0, 0, 868, 864, 1, 0, + 0, 0, 868, 865, 1, 0, 0, 0, 869, 19, 1, 0, 0, 0, 870, 896, 3, 426, 213, + 0, 871, 896, 3, 428, 214, 0, 872, 896, 3, 430, 215, 0, 873, 896, 3, 432, + 216, 0, 874, 896, 3, 436, 218, 0, 875, 896, 3, 438, 219, 0, 876, 896, 3, + 440, 220, 0, 877, 896, 3, 442, 221, 0, 878, 896, 3, 470, 235, 0, 879, 896, + 3, 472, 236, 0, 880, 896, 3, 474, 237, 0, 881, 896, 3, 476, 238, 0, 882, + 896, 3, 478, 239, 0, 883, 896, 3, 482, 241, 0, 884, 896, 3, 484, 242, 0, + 885, 896, 3, 486, 243, 0, 886, 896, 3, 488, 244, 0, 887, 896, 3, 490, 245, + 0, 888, 896, 3, 504, 252, 0, 889, 896, 3, 506, 253, 0, 890, 896, 3, 508, + 254, 0, 891, 896, 3, 510, 255, 0, 892, 896, 3, 512, 256, 0, 893, 896, 3, + 514, 257, 0, 894, 896, 3, 516, 258, 0, 895, 870, 1, 0, 0, 0, 895, 871, + 1, 0, 0, 0, 895, 872, 1, 0, 0, 0, 895, 873, 1, 0, 0, 0, 895, 874, 1, 0, + 0, 0, 895, 875, 1, 0, 0, 0, 895, 876, 1, 0, 0, 0, 895, 877, 1, 0, 0, 0, + 895, 878, 1, 0, 0, 0, 895, 879, 1, 0, 0, 0, 895, 880, 1, 0, 0, 0, 895, + 881, 1, 0, 0, 0, 895, 882, 1, 0, 0, 0, 895, 883, 1, 0, 0, 0, 895, 884, + 1, 0, 0, 0, 895, 885, 1, 0, 0, 0, 895, 886, 1, 0, 0, 0, 895, 887, 1, 0, + 0, 0, 895, 888, 1, 0, 0, 0, 895, 889, 1, 0, 0, 0, 895, 890, 1, 0, 0, 0, + 895, 891, 1, 0, 0, 0, 895, 892, 1, 0, 0, 0, 895, 893, 1, 0, 0, 0, 895, + 894, 1, 0, 0, 0, 896, 21, 1, 0, 0, 0, 897, 905, 3, 526, 263, 0, 898, 905, + 3, 528, 264, 0, 899, 905, 3, 530, 265, 0, 900, 905, 3, 532, 266, 0, 901, + 905, 3, 534, 267, 0, 902, 905, 3, 536, 268, 0, 903, 905, 3, 544, 272, 0, + 904, 897, 1, 0, 0, 0, 904, 898, 1, 0, 0, 0, 904, 899, 1, 0, 0, 0, 904, + 900, 1, 0, 0, 0, 904, 901, 1, 0, 0, 0, 904, 902, 1, 0, 0, 0, 904, 903, + 1, 0, 0, 0, 905, 23, 1, 0, 0, 0, 906, 907, 5, 33, 0, 0, 907, 909, 7, 0, + 0, 0, 908, 910, 3, 642, 321, 0, 909, 908, 1, 0, 0, 0, 909, 910, 1, 0, 0, + 0, 910, 911, 1, 0, 0, 0, 911, 915, 3, 584, 292, 0, 912, 914, 3, 58, 29, + 0, 913, 912, 1, 0, 0, 0, 914, 917, 1, 0, 0, 0, 915, 913, 1, 0, 0, 0, 915, + 916, 1, 0, 0, 0, 916, 25, 1, 0, 0, 0, 917, 915, 1, 0, 0, 0, 918, 920, 5, + 33, 0, 0, 919, 921, 3, 64, 32, 0, 920, 919, 1, 0, 0, 0, 920, 921, 1, 0, + 0, 0, 921, 922, 1, 0, 0, 0, 922, 924, 5, 416, 0, 0, 923, 925, 3, 642, 321, + 0, 924, 923, 1, 0, 0, 0, 924, 925, 1, 0, 0, 0, 925, 926, 1, 0, 0, 0, 926, + 927, 3, 550, 275, 0, 927, 928, 5, 118, 0, 0, 928, 929, 5, 606, 0, 0, 929, + 936, 3, 66, 33, 0, 930, 931, 5, 118, 0, 0, 931, 933, 5, 372, 0, 0, 932, + 934, 5, 114, 0, 0, 933, 932, 1, 0, 0, 0, 933, 934, 1, 0, 0, 0, 934, 935, + 1, 0, 0, 0, 935, 937, 5, 562, 0, 0, 936, 930, 1, 0, 0, 0, 936, 937, 1, + 0, 0, 0, 937, 939, 1, 0, 0, 0, 938, 940, 3, 74, 37, 0, 939, 938, 1, 0, + 0, 0, 939, 940, 1, 0, 0, 0, 940, 943, 1, 0, 0, 0, 941, 942, 5, 369, 0, + 0, 942, 944, 5, 1153, 0, 0, 943, 941, 1, 0, 0, 0, 943, 944, 1, 0, 0, 0, + 944, 945, 1, 0, 0, 0, 945, 946, 5, 400, 0, 0, 946, 947, 3, 388, 194, 0, + 947, 27, 1, 0, 0, 0, 948, 950, 5, 33, 0, 0, 949, 951, 7, 1, 0, 0, 950, + 949, 1, 0, 0, 0, 950, 951, 1, 0, 0, 0, 951, 953, 1, 0, 0, 0, 952, 954, + 7, 2, 0, 0, 953, 952, 1, 0, 0, 0, 953, 954, 1, 0, 0, 0, 954, 955, 1, 0, + 0, 0, 955, 956, 5, 81, 0, 0, 956, 958, 3, 584, 292, 0, 957, 959, 3, 76, + 38, 0, 958, 957, 1, 0, 0, 0, 958, 959, 1, 0, 0, 0, 959, 960, 1, 0, 0, 0, + 960, 961, 5, 118, 0, 0, 961, 962, 3, 552, 276, 0, 962, 966, 3, 622, 311, + 0, 963, 965, 3, 78, 39, 0, 964, 963, 1, 0, 0, 0, 965, 968, 1, 0, 0, 0, + 966, 964, 1, 0, 0, 0, 966, 967, 1, 0, 0, 0, 967, 981, 1, 0, 0, 0, 968, + 966, 1, 0, 0, 0, 969, 971, 5, 337, 0, 0, 970, 972, 5, 1129, 0, 0, 971, + 970, 1, 0, 0, 0, 971, 972, 1, 0, 0, 0, 972, 973, 1, 0, 0, 0, 973, 980, + 7, 3, 0, 0, 974, 976, 5, 103, 0, 0, 975, 977, 5, 1129, 0, 0, 976, 975, + 1, 0, 0, 0, 976, 977, 1, 0, 0, 0, 977, 978, 1, 0, 0, 0, 978, 980, 7, 4, + 0, 0, 979, 969, 1, 0, 0, 0, 979, 974, 1, 0, 0, 0, 980, 983, 1, 0, 0, 0, + 981, 979, 1, 0, 0, 0, 981, 982, 1, 0, 0, 0, 982, 29, 1, 0, 0, 0, 983, 981, + 1, 0, 0, 0, 984, 985, 5, 33, 0, 0, 985, 986, 5, 476, 0, 0, 986, 987, 5, + 73, 0, 0, 987, 988, 3, 584, 292, 0, 988, 989, 5, 5, 0, 0, 989, 990, 5, + 660, 0, 0, 990, 996, 5, 1153, 0, 0, 991, 993, 5, 454, 0, 0, 992, 994, 5, + 1129, 0, 0, 993, 992, 1, 0, 0, 0, 993, 994, 1, 0, 0, 0, 994, 995, 1, 0, + 0, 0, 995, 997, 3, 592, 296, 0, 996, 991, 1, 0, 0, 0, 996, 997, 1, 0, 0, + 0, 997, 1003, 1, 0, 0, 0, 998, 1000, 5, 661, 0, 0, 999, 1001, 5, 1129, + 0, 0, 1000, 999, 1, 0, 0, 0, 1000, 1001, 1, 0, 0, 0, 1001, 1002, 1, 0, + 0, 0, 1002, 1004, 3, 592, 296, 0, 1003, 998, 1, 0, 0, 0, 1003, 1004, 1, + 0, 0, 0, 1004, 1010, 1, 0, 0, 0, 1005, 1007, 5, 573, 0, 0, 1006, 1008, + 5, 1129, 0, 0, 1007, 1006, 1, 0, 0, 0, 1007, 1008, 1, 0, 0, 0, 1008, 1009, + 1, 0, 0, 0, 1009, 1011, 3, 592, 296, 0, 1010, 1005, 1, 0, 0, 0, 1010, 1011, + 1, 0, 0, 0, 1011, 1017, 1, 0, 0, 0, 1012, 1014, 5, 529, 0, 0, 1013, 1015, + 5, 1129, 0, 0, 1014, 1013, 1, 0, 0, 0, 1014, 1015, 1, 0, 0, 0, 1015, 1016, + 1, 0, 0, 0, 1016, 1018, 3, 584, 292, 0, 1017, 1012, 1, 0, 0, 0, 1017, 1018, + 1, 0, 0, 0, 1018, 1020, 1, 0, 0, 0, 1019, 1021, 5, 675, 0, 0, 1020, 1019, + 1, 0, 0, 0, 1020, 1021, 1, 0, 0, 0, 1021, 1027, 1, 0, 0, 0, 1022, 1024, + 5, 369, 0, 0, 1023, 1025, 5, 1129, 0, 0, 1024, 1023, 1, 0, 0, 0, 1024, + 1025, 1, 0, 0, 0, 1025, 1026, 1, 0, 0, 0, 1026, 1028, 5, 1153, 0, 0, 1027, + 1022, 1, 0, 0, 0, 1027, 1028, 1, 0, 0, 0, 1028, 1029, 1, 0, 0, 0, 1029, + 1031, 5, 410, 0, 0, 1030, 1032, 5, 1129, 0, 0, 1031, 1030, 1, 0, 0, 0, + 1031, 1032, 1, 0, 0, 0, 1032, 1033, 1, 0, 0, 0, 1033, 1034, 3, 572, 286, + 0, 1034, 31, 1, 0, 0, 0, 1035, 1037, 5, 33, 0, 0, 1036, 1038, 3, 64, 32, + 0, 1037, 1036, 1, 0, 0, 0, 1037, 1038, 1, 0, 0, 0, 1038, 1039, 1, 0, 0, + 0, 1039, 1040, 5, 131, 0, 0, 1040, 1041, 3, 550, 275, 0, 1041, 1043, 5, + 1138, 0, 0, 1042, 1044, 3, 80, 40, 0, 1043, 1042, 1, 0, 0, 0, 1043, 1044, + 1, 0, 0, 0, 1044, 1049, 1, 0, 0, 0, 1045, 1046, 5, 1140, 0, 0, 1046, 1048, + 3, 80, 40, 0, 1047, 1045, 1, 0, 0, 0, 1048, 1051, 1, 0, 0, 0, 1049, 1047, + 1, 0, 0, 0, 1049, 1050, 1, 0, 0, 0, 1050, 1052, 1, 0, 0, 0, 1051, 1049, + 1, 0, 0, 0, 1052, 1056, 5, 1139, 0, 0, 1053, 1055, 3, 84, 42, 0, 1054, + 1053, 1, 0, 0, 0, 1055, 1058, 1, 0, 0, 0, 1056, 1054, 1, 0, 0, 0, 1056, + 1057, 1, 0, 0, 0, 1057, 1059, 1, 0, 0, 0, 1058, 1056, 1, 0, 0, 0, 1059, + 1060, 3, 388, 194, 0, 1060, 33, 1, 0, 0, 0, 1061, 1063, 5, 33, 0, 0, 1062, + 1064, 3, 64, 32, 0, 1063, 1062, 1, 0, 0, 0, 1063, 1064, 1, 0, 0, 0, 1064, + 1066, 1, 0, 0, 0, 1065, 1067, 5, 336, 0, 0, 1066, 1065, 1, 0, 0, 0, 1066, + 1067, 1, 0, 0, 0, 1067, 1068, 1, 0, 0, 0, 1068, 1070, 5, 438, 0, 0, 1069, + 1071, 3, 642, 321, 0, 1070, 1069, 1, 0, 0, 0, 1070, 1071, 1, 0, 0, 0, 1071, + 1072, 1, 0, 0, 0, 1072, 1073, 3, 550, 275, 0, 1073, 1075, 5, 1138, 0, 0, + 1074, 1076, 3, 82, 41, 0, 1075, 1074, 1, 0, 0, 0, 1075, 1076, 1, 0, 0, + 0, 1076, 1081, 1, 0, 0, 0, 1077, 1078, 5, 1140, 0, 0, 1078, 1080, 3, 82, + 41, 0, 1079, 1077, 1, 0, 0, 0, 1080, 1083, 1, 0, 0, 0, 1081, 1079, 1, 0, + 0, 0, 1081, 1082, 1, 0, 0, 0, 1082, 1084, 1, 0, 0, 0, 1083, 1081, 1, 0, + 0, 0, 1084, 1085, 5, 1139, 0, 0, 1085, 1086, 5, 595, 0, 0, 1086, 1090, + 3, 604, 302, 0, 1087, 1089, 3, 84, 42, 0, 1088, 1087, 1, 0, 0, 0, 1089, + 1092, 1, 0, 0, 0, 1090, 1088, 1, 0, 0, 0, 1090, 1091, 1, 0, 0, 0, 1091, + 1095, 1, 0, 0, 0, 1092, 1090, 1, 0, 0, 0, 1093, 1096, 3, 388, 194, 0, 1094, + 1096, 3, 404, 202, 0, 1095, 1093, 1, 0, 0, 0, 1095, 1094, 1, 0, 0, 0, 1096, + 35, 1, 0, 0, 0, 1097, 1098, 5, 33, 0, 0, 1098, 1100, 5, 597, 0, 0, 1099, + 1101, 3, 642, 321, 0, 1100, 1099, 1, 0, 0, 0, 1100, 1101, 1, 0, 0, 0, 1101, + 1102, 1, 0, 0, 0, 1102, 1107, 3, 554, 277, 0, 1103, 1104, 5, 1140, 0, 0, + 1104, 1106, 3, 554, 277, 0, 1105, 1103, 1, 0, 0, 0, 1106, 1109, 1, 0, 0, + 0, 1107, 1105, 1, 0, 0, 0, 1107, 1108, 1, 0, 0, 0, 1108, 37, 1, 0, 0, 0, + 1109, 1107, 1, 0, 0, 0, 1110, 1111, 5, 33, 0, 0, 1111, 1112, 5, 609, 0, + 0, 1112, 1113, 3, 584, 292, 0, 1113, 1114, 5, 67, 0, 0, 1114, 1115, 5, + 389, 0, 0, 1115, 1116, 5, 680, 0, 0, 1116, 1117, 7, 5, 0, 0, 1117, 1118, + 5, 542, 0, 0, 1118, 1119, 5, 1138, 0, 0, 1119, 1124, 3, 86, 43, 0, 1120, + 1121, 5, 1140, 0, 0, 1121, 1123, 3, 86, 43, 0, 1122, 1120, 1, 0, 0, 0, + 1123, 1126, 1, 0, 0, 0, 1124, 1122, 1, 0, 0, 0, 1124, 1125, 1, 0, 0, 0, + 1125, 1127, 1, 0, 0, 0, 1126, 1124, 1, 0, 0, 0, 1127, 1128, 5, 1139, 0, + 0, 1128, 39, 1, 0, 0, 0, 1129, 1131, 5, 33, 0, 0, 1130, 1132, 5, 650, 0, + 0, 1131, 1130, 1, 0, 0, 0, 1131, 1132, 1, 0, 0, 0, 1132, 1133, 1, 0, 0, + 0, 1133, 1135, 5, 172, 0, 0, 1134, 1136, 3, 642, 321, 0, 1135, 1134, 1, + 0, 0, 0, 1135, 1136, 1, 0, 0, 0, 1136, 1137, 1, 0, 0, 0, 1137, 1145, 3, + 552, 276, 0, 1138, 1139, 5, 98, 0, 0, 1139, 1146, 3, 552, 276, 0, 1140, + 1141, 5, 1138, 0, 0, 1141, 1142, 5, 98, 0, 0, 1142, 1143, 3, 552, 276, + 0, 1143, 1144, 5, 1139, 0, 0, 1144, 1146, 1, 0, 0, 0, 1145, 1138, 1, 0, + 0, 0, 1145, 1140, 1, 0, 0, 0, 1146, 1208, 1, 0, 0, 0, 1147, 1149, 5, 33, + 0, 0, 1148, 1150, 5, 650, 0, 0, 1149, 1148, 1, 0, 0, 0, 1149, 1150, 1, + 0, 0, 0, 1150, 1151, 1, 0, 0, 0, 1151, 1153, 5, 172, 0, 0, 1152, 1154, + 3, 642, 321, 0, 1153, 1152, 1, 0, 0, 0, 1153, 1154, 1, 0, 0, 0, 1154, 1155, + 1, 0, 0, 0, 1155, 1157, 3, 552, 276, 0, 1156, 1158, 3, 88, 44, 0, 1157, + 1156, 1, 0, 0, 0, 1157, 1158, 1, 0, 0, 0, 1158, 1169, 1, 0, 0, 0, 1159, + 1166, 3, 106, 53, 0, 1160, 1162, 5, 1140, 0, 0, 1161, 1160, 1, 0, 0, 0, + 1161, 1162, 1, 0, 0, 0, 1162, 1163, 1, 0, 0, 0, 1163, 1165, 3, 106, 53, + 0, 1164, 1161, 1, 0, 0, 0, 1165, 1168, 1, 0, 0, 0, 1166, 1164, 1, 0, 0, + 0, 1166, 1167, 1, 0, 0, 0, 1167, 1170, 1, 0, 0, 0, 1168, 1166, 1, 0, 0, + 0, 1169, 1159, 1, 0, 0, 0, 1169, 1170, 1, 0, 0, 0, 1170, 1172, 1, 0, 0, + 0, 1171, 1173, 3, 112, 56, 0, 1172, 1171, 1, 0, 0, 0, 1172, 1173, 1, 0, + 0, 0, 1173, 1175, 1, 0, 0, 0, 1174, 1176, 7, 6, 0, 0, 1175, 1174, 1, 0, + 0, 0, 1175, 1176, 1, 0, 0, 0, 1176, 1178, 1, 0, 0, 0, 1177, 1179, 5, 12, + 0, 0, 1178, 1177, 1, 0, 0, 0, 1178, 1179, 1, 0, 0, 0, 1179, 1180, 1, 0, + 0, 0, 1180, 1181, 3, 200, 100, 0, 1181, 1208, 1, 0, 0, 0, 1182, 1184, 5, + 33, 0, 0, 1183, 1185, 5, 650, 0, 0, 1184, 1183, 1, 0, 0, 0, 1184, 1185, + 1, 0, 0, 0, 1185, 1186, 1, 0, 0, 0, 1186, 1188, 5, 172, 0, 0, 1187, 1189, + 3, 642, 321, 0, 1188, 1187, 1, 0, 0, 0, 1188, 1189, 1, 0, 0, 0, 1189, 1190, + 1, 0, 0, 0, 1190, 1191, 3, 552, 276, 0, 1191, 1202, 3, 88, 44, 0, 1192, + 1199, 3, 106, 53, 0, 1193, 1195, 5, 1140, 0, 0, 1194, 1193, 1, 0, 0, 0, + 1194, 1195, 1, 0, 0, 0, 1195, 1196, 1, 0, 0, 0, 1196, 1198, 3, 106, 53, + 0, 1197, 1194, 1, 0, 0, 0, 1198, 1201, 1, 0, 0, 0, 1199, 1197, 1, 0, 0, + 0, 1199, 1200, 1, 0, 0, 0, 1200, 1203, 1, 0, 0, 0, 1201, 1199, 1, 0, 0, + 0, 1202, 1192, 1, 0, 0, 0, 1202, 1203, 1, 0, 0, 0, 1203, 1205, 1, 0, 0, + 0, 1204, 1206, 3, 112, 56, 0, 1205, 1204, 1, 0, 0, 0, 1205, 1206, 1, 0, + 0, 0, 1206, 1208, 1, 0, 0, 0, 1207, 1129, 1, 0, 0, 0, 1207, 1147, 1, 0, + 0, 0, 1207, 1182, 1, 0, 0, 0, 1208, 41, 1, 0, 0, 0, 1209, 1210, 5, 33, + 0, 0, 1210, 1211, 5, 648, 0, 0, 1211, 1212, 3, 584, 292, 0, 1212, 1213, + 5, 5, 0, 0, 1213, 1214, 5, 390, 0, 0, 1214, 1218, 5, 1153, 0, 0, 1215, + 1216, 5, 429, 0, 0, 1216, 1217, 5, 1129, 0, 0, 1217, 1219, 3, 592, 296, + 0, 1218, 1215, 1, 0, 0, 0, 1218, 1219, 1, 0, 0, 0, 1219, 1225, 1, 0, 0, + 0, 1220, 1222, 5, 410, 0, 0, 1221, 1223, 5, 1129, 0, 0, 1222, 1221, 1, + 0, 0, 0, 1222, 1223, 1, 0, 0, 0, 1223, 1224, 1, 0, 0, 0, 1224, 1226, 3, + 572, 286, 0, 1225, 1220, 1, 0, 0, 0, 1225, 1226, 1, 0, 0, 0, 1226, 43, + 1, 0, 0, 0, 1227, 1228, 5, 33, 0, 0, 1228, 1229, 5, 648, 0, 0, 1229, 1230, + 3, 584, 292, 0, 1230, 1231, 5, 5, 0, 0, 1231, 1232, 5, 390, 0, 0, 1232, + 1233, 5, 1153, 0, 0, 1233, 1234, 5, 186, 0, 0, 1234, 1235, 5, 476, 0, 0, + 1235, 1236, 5, 73, 0, 0, 1236, 1242, 3, 584, 292, 0, 1237, 1239, 5, 424, + 0, 0, 1238, 1240, 5, 1129, 0, 0, 1239, 1238, 1, 0, 0, 0, 1239, 1240, 1, + 0, 0, 0, 1240, 1241, 1, 0, 0, 0, 1241, 1243, 3, 592, 296, 0, 1242, 1237, + 1, 0, 0, 0, 1242, 1243, 1, 0, 0, 0, 1243, 1249, 1, 0, 0, 0, 1244, 1246, + 5, 454, 0, 0, 1245, 1247, 5, 1129, 0, 0, 1246, 1245, 1, 0, 0, 0, 1246, + 1247, 1, 0, 0, 0, 1247, 1248, 1, 0, 0, 0, 1248, 1250, 3, 592, 296, 0, 1249, + 1244, 1, 0, 0, 0, 1249, 1250, 1, 0, 0, 0, 1250, 1256, 1, 0, 0, 0, 1251, + 1253, 5, 342, 0, 0, 1252, 1254, 5, 1129, 0, 0, 1253, 1252, 1, 0, 0, 0, + 1253, 1254, 1, 0, 0, 0, 1254, 1255, 1, 0, 0, 0, 1255, 1257, 3, 592, 296, + 0, 1256, 1251, 1, 0, 0, 0, 1256, 1257, 1, 0, 0, 0, 1257, 1263, 1, 0, 0, + 0, 1258, 1260, 5, 502, 0, 0, 1259, 1261, 5, 1129, 0, 0, 1260, 1259, 1, + 0, 0, 0, 1260, 1261, 1, 0, 0, 0, 1261, 1262, 1, 0, 0, 0, 1262, 1264, 3, + 592, 296, 0, 1263, 1258, 1, 0, 0, 0, 1263, 1264, 1, 0, 0, 0, 1264, 1270, + 1, 0, 0, 0, 1265, 1267, 5, 529, 0, 0, 1266, 1268, 5, 1129, 0, 0, 1267, + 1266, 1, 0, 0, 0, 1267, 1268, 1, 0, 0, 0, 1268, 1269, 1, 0, 0, 0, 1269, + 1271, 3, 584, 292, 0, 1270, 1265, 1, 0, 0, 0, 1270, 1271, 1, 0, 0, 0, 1271, + 1273, 1, 0, 0, 0, 1272, 1274, 5, 675, 0, 0, 1273, 1272, 1, 0, 0, 0, 1273, + 1274, 1, 0, 0, 0, 1274, 1280, 1, 0, 0, 0, 1275, 1277, 5, 369, 0, 0, 1276, + 1278, 5, 1129, 0, 0, 1277, 1276, 1, 0, 0, 0, 1277, 1278, 1, 0, 0, 0, 1278, + 1279, 1, 0, 0, 0, 1279, 1281, 5, 1153, 0, 0, 1280, 1275, 1, 0, 0, 0, 1280, + 1281, 1, 0, 0, 0, 1281, 1282, 1, 0, 0, 0, 1282, 1284, 5, 410, 0, 0, 1283, + 1285, 5, 1129, 0, 0, 1284, 1283, 1, 0, 0, 0, 1284, 1285, 1, 0, 0, 0, 1285, + 1286, 1, 0, 0, 0, 1286, 1287, 3, 572, 286, 0, 1287, 45, 1, 0, 0, 0, 1288, + 1290, 5, 33, 0, 0, 1289, 1291, 3, 64, 32, 0, 1290, 1289, 1, 0, 0, 0, 1290, + 1291, 1, 0, 0, 0, 1291, 1292, 1, 0, 0, 0, 1292, 1294, 5, 177, 0, 0, 1293, + 1295, 3, 642, 321, 0, 1294, 1293, 1, 0, 0, 0, 1294, 1295, 1, 0, 0, 0, 1295, + 1296, 1, 0, 0, 0, 1296, 1297, 3, 550, 275, 0, 1297, 1298, 7, 7, 0, 0, 1298, + 1299, 7, 8, 0, 0, 1299, 1300, 5, 118, 0, 0, 1300, 1301, 3, 552, 276, 0, + 1301, 1302, 5, 65, 0, 0, 1302, 1303, 5, 52, 0, 0, 1303, 1306, 5, 601, 0, + 0, 1304, 1305, 7, 9, 0, 0, 1305, 1307, 3, 550, 275, 0, 1306, 1304, 1, 0, + 0, 0, 1306, 1307, 1, 0, 0, 0, 1307, 1308, 1, 0, 0, 0, 1308, 1309, 3, 388, + 194, 0, 1309, 47, 1, 0, 0, 0, 1310, 1312, 5, 192, 0, 0, 1311, 1313, 5, + 572, 0, 0, 1312, 1311, 1, 0, 0, 0, 1312, 1313, 1, 0, 0, 0, 1313, 1314, + 1, 0, 0, 0, 1314, 1315, 3, 50, 25, 0, 1315, 49, 1, 0, 0, 0, 1316, 1328, + 3, 52, 26, 0, 1317, 1318, 5, 1138, 0, 0, 1318, 1323, 3, 54, 27, 0, 1319, + 1320, 5, 1140, 0, 0, 1320, 1322, 3, 54, 27, 0, 1321, 1319, 1, 0, 0, 0, + 1322, 1325, 1, 0, 0, 0, 1323, 1321, 1, 0, 0, 0, 1323, 1324, 1, 0, 0, 0, + 1324, 1326, 1, 0, 0, 0, 1325, 1323, 1, 0, 0, 0, 1326, 1327, 5, 1139, 0, + 0, 1327, 1329, 1, 0, 0, 0, 1328, 1317, 1, 0, 0, 0, 1328, 1329, 1, 0, 0, + 0, 1329, 1330, 1, 0, 0, 0, 1330, 1331, 5, 12, 0, 0, 1331, 1332, 5, 1138, + 0, 0, 1332, 1333, 3, 10, 5, 0, 1333, 1336, 5, 1139, 0, 0, 1334, 1335, 5, + 1140, 0, 0, 1335, 1337, 3, 50, 25, 0, 1336, 1334, 1, 0, 0, 0, 1336, 1337, + 1, 0, 0, 0, 1337, 51, 1, 0, 0, 0, 1338, 1339, 3, 584, 292, 0, 1339, 53, + 1, 0, 0, 0, 1340, 1341, 3, 584, 292, 0, 1341, 55, 1, 0, 0, 0, 1342, 1344, + 5, 33, 0, 0, 1343, 1345, 3, 644, 322, 0, 1344, 1343, 1, 0, 0, 0, 1344, + 1345, 1, 0, 0, 0, 1345, 1349, 1, 0, 0, 0, 1346, 1347, 5, 337, 0, 0, 1347, + 1348, 5, 1129, 0, 0, 1348, 1350, 7, 10, 0, 0, 1349, 1346, 1, 0, 0, 0, 1349, + 1350, 1, 0, 0, 0, 1350, 1352, 1, 0, 0, 0, 1351, 1353, 3, 64, 32, 0, 1352, + 1351, 1, 0, 0, 0, 1352, 1353, 1, 0, 0, 0, 1353, 1357, 1, 0, 0, 0, 1354, + 1355, 5, 160, 0, 0, 1355, 1356, 5, 607, 0, 0, 1356, 1358, 7, 11, 0, 0, + 1357, 1354, 1, 0, 0, 0, 1357, 1358, 1, 0, 0, 0, 1358, 1359, 1, 0, 0, 0, + 1359, 1360, 5, 672, 0, 0, 1360, 1365, 3, 550, 275, 0, 1361, 1362, 5, 1138, + 0, 0, 1362, 1363, 3, 616, 308, 0, 1363, 1364, 5, 1139, 0, 0, 1364, 1366, + 1, 0, 0, 0, 1365, 1361, 1, 0, 0, 0, 1365, 1366, 1, 0, 0, 0, 1366, 1367, + 1, 0, 0, 0, 1367, 1387, 5, 12, 0, 0, 1368, 1370, 5, 1138, 0, 0, 1369, 1371, + 3, 48, 24, 0, 1370, 1369, 1, 0, 0, 0, 1370, 1371, 1, 0, 0, 0, 1371, 1372, + 1, 0, 0, 0, 1372, 1373, 3, 200, 100, 0, 1373, 1374, 5, 1139, 0, 0, 1374, + 1388, 1, 0, 0, 0, 1375, 1377, 3, 48, 24, 0, 1376, 1375, 1, 0, 0, 0, 1376, + 1377, 1, 0, 0, 0, 1377, 1378, 1, 0, 0, 0, 1378, 1385, 3, 200, 100, 0, 1379, + 1381, 5, 192, 0, 0, 1380, 1382, 7, 12, 0, 0, 1381, 1380, 1, 0, 0, 0, 1381, + 1382, 1, 0, 0, 0, 1382, 1383, 1, 0, 0, 0, 1383, 1384, 5, 26, 0, 0, 1384, + 1386, 5, 120, 0, 0, 1385, 1379, 1, 0, 0, 0, 1385, 1386, 1, 0, 0, 0, 1386, + 1388, 1, 0, 0, 0, 1387, 1368, 1, 0, 0, 0, 1387, 1376, 1, 0, 0, 0, 1388, + 57, 1, 0, 0, 0, 1389, 1391, 5, 42, 0, 0, 1390, 1389, 1, 0, 0, 0, 1390, + 1391, 1, 0, 0, 0, 1391, 1392, 1, 0, 0, 0, 1392, 1394, 3, 60, 30, 0, 1393, + 1395, 5, 1129, 0, 0, 1394, 1393, 1, 0, 0, 0, 1394, 1395, 1, 0, 0, 0, 1395, + 1398, 1, 0, 0, 0, 1396, 1399, 3, 568, 284, 0, 1397, 1399, 5, 42, 0, 0, + 1398, 1396, 1, 0, 0, 0, 1398, 1397, 1, 0, 0, 0, 1399, 1423, 1, 0, 0, 0, + 1400, 1402, 5, 42, 0, 0, 1401, 1400, 1, 0, 0, 0, 1401, 1402, 1, 0, 0, 0, + 1402, 1403, 1, 0, 0, 0, 1403, 1405, 5, 27, 0, 0, 1404, 1406, 5, 1129, 0, + 0, 1405, 1404, 1, 0, 0, 0, 1405, 1406, 1, 0, 0, 0, 1406, 1407, 1, 0, 0, + 0, 1407, 1423, 3, 570, 285, 0, 1408, 1410, 5, 42, 0, 0, 1409, 1408, 1, + 0, 0, 0, 1409, 1410, 1, 0, 0, 0, 1410, 1411, 1, 0, 0, 0, 1411, 1413, 5, + 406, 0, 0, 1412, 1414, 5, 1129, 0, 0, 1413, 1412, 1, 0, 0, 0, 1413, 1414, + 1, 0, 0, 0, 1414, 1415, 1, 0, 0, 0, 1415, 1423, 5, 1153, 0, 0, 1416, 1417, + 5, 134, 0, 0, 1417, 1419, 5, 539, 0, 0, 1418, 1420, 5, 1129, 0, 0, 1419, + 1418, 1, 0, 0, 0, 1419, 1420, 1, 0, 0, 0, 1420, 1421, 1, 0, 0, 0, 1421, + 1423, 7, 13, 0, 0, 1422, 1390, 1, 0, 0, 0, 1422, 1401, 1, 0, 0, 0, 1422, + 1409, 1, 0, 0, 0, 1422, 1416, 1, 0, 0, 0, 1423, 59, 1, 0, 0, 0, 1424, 1425, + 5, 25, 0, 0, 1425, 1430, 5, 153, 0, 0, 1426, 1430, 5, 842, 0, 0, 1427, + 1428, 5, 222, 0, 0, 1428, 1430, 5, 153, 0, 0, 1429, 1424, 1, 0, 0, 0, 1429, + 1426, 1, 0, 0, 0, 1429, 1427, 1, 0, 0, 0, 1430, 61, 1, 0, 0, 0, 1431, 1434, + 5, 37, 0, 0, 1432, 1433, 5, 1138, 0, 0, 1433, 1435, 5, 1139, 0, 0, 1434, + 1432, 1, 0, 0, 0, 1434, 1435, 1, 0, 0, 0, 1435, 63, 1, 0, 0, 0, 1436, 1437, + 5, 393, 0, 0, 1437, 1440, 5, 1129, 0, 0, 1438, 1441, 3, 564, 282, 0, 1439, + 1441, 3, 62, 31, 0, 1440, 1438, 1, 0, 0, 0, 1440, 1439, 1, 0, 0, 0, 1441, + 65, 1, 0, 0, 0, 1442, 1443, 5, 339, 0, 0, 1443, 1447, 3, 68, 34, 0, 1444, + 1446, 3, 70, 35, 0, 1445, 1444, 1, 0, 0, 0, 1446, 1449, 1, 0, 0, 0, 1447, + 1445, 1, 0, 0, 0, 1447, 1448, 1, 0, 0, 0, 1448, 1477, 1, 0, 0, 0, 1449, + 1447, 1, 0, 0, 0, 1450, 1453, 5, 418, 0, 0, 1451, 1454, 3, 590, 295, 0, + 1452, 1454, 3, 688, 344, 0, 1453, 1451, 1, 0, 0, 0, 1453, 1452, 1, 0, 0, + 0, 1454, 1455, 1, 0, 0, 0, 1455, 1464, 3, 72, 36, 0, 1456, 1457, 5, 631, + 0, 0, 1457, 1461, 3, 68, 34, 0, 1458, 1460, 3, 70, 35, 0, 1459, 1458, 1, + 0, 0, 0, 1460, 1463, 1, 0, 0, 0, 1461, 1459, 1, 0, 0, 0, 1461, 1462, 1, + 0, 0, 0, 1462, 1465, 1, 0, 0, 0, 1463, 1461, 1, 0, 0, 0, 1464, 1456, 1, + 0, 0, 0, 1464, 1465, 1, 0, 0, 0, 1465, 1474, 1, 0, 0, 0, 1466, 1467, 5, + 409, 0, 0, 1467, 1471, 3, 68, 34, 0, 1468, 1470, 3, 70, 35, 0, 1469, 1468, + 1, 0, 0, 0, 1470, 1473, 1, 0, 0, 0, 1471, 1469, 1, 0, 0, 0, 1471, 1472, + 1, 0, 0, 0, 1472, 1475, 1, 0, 0, 0, 1473, 1471, 1, 0, 0, 0, 1474, 1466, + 1, 0, 0, 0, 1474, 1475, 1, 0, 0, 0, 1475, 1477, 1, 0, 0, 0, 1476, 1442, + 1, 0, 0, 0, 1476, 1450, 1, 0, 0, 0, 1477, 67, 1, 0, 0, 0, 1478, 1483, 5, + 316, 0, 0, 1479, 1483, 3, 594, 297, 0, 1480, 1483, 3, 590, 295, 0, 1481, + 1483, 3, 688, 344, 0, 1482, 1478, 1, 0, 0, 0, 1482, 1479, 1, 0, 0, 0, 1482, + 1480, 1, 0, 0, 0, 1482, 1481, 1, 0, 0, 0, 1483, 69, 1, 0, 0, 0, 1484, 1485, + 5, 1125, 0, 0, 1485, 1488, 5, 86, 0, 0, 1486, 1489, 3, 590, 295, 0, 1487, + 1489, 3, 688, 344, 0, 1488, 1486, 1, 0, 0, 0, 1488, 1487, 1, 0, 0, 0, 1489, + 1490, 1, 0, 0, 0, 1490, 1491, 3, 72, 36, 0, 1491, 71, 1, 0, 0, 0, 1492, + 1506, 3, 714, 357, 0, 1493, 1506, 5, 221, 0, 0, 1494, 1506, 5, 241, 0, + 0, 1495, 1506, 5, 242, 0, 0, 1496, 1506, 5, 243, 0, 0, 1497, 1506, 5, 244, + 0, 0, 1498, 1506, 5, 245, 0, 0, 1499, 1506, 5, 246, 0, 0, 1500, 1506, 5, + 247, 0, 0, 1501, 1506, 5, 248, 0, 0, 1502, 1506, 5, 249, 0, 0, 1503, 1506, + 5, 250, 0, 0, 1504, 1506, 5, 251, 0, 0, 1505, 1492, 1, 0, 0, 0, 1505, 1493, + 1, 0, 0, 0, 1505, 1494, 1, 0, 0, 0, 1505, 1495, 1, 0, 0, 0, 1505, 1496, + 1, 0, 0, 0, 1505, 1497, 1, 0, 0, 0, 1505, 1498, 1, 0, 0, 0, 1505, 1499, + 1, 0, 0, 0, 1505, 1500, 1, 0, 0, 0, 1505, 1501, 1, 0, 0, 0, 1505, 1502, + 1, 0, 0, 0, 1505, 1503, 1, 0, 0, 0, 1505, 1504, 1, 0, 0, 0, 1506, 73, 1, + 0, 0, 0, 1507, 1513, 5, 404, 0, 0, 1508, 1513, 5, 397, 0, 0, 1509, 1510, + 5, 397, 0, 0, 1510, 1511, 5, 118, 0, 0, 1511, 1513, 5, 615, 0, 0, 1512, + 1507, 1, 0, 0, 0, 1512, 1508, 1, 0, 0, 0, 1512, 1509, 1, 0, 0, 0, 1513, + 75, 1, 0, 0, 0, 1514, 1515, 5, 187, 0, 0, 1515, 1516, 7, 14, 0, 0, 1516, + 77, 1, 0, 0, 0, 1517, 1519, 5, 468, 0, 0, 1518, 1520, 5, 1129, 0, 0, 1519, + 1518, 1, 0, 0, 0, 1519, 1520, 1, 0, 0, 0, 1520, 1521, 1, 0, 0, 0, 1521, + 1540, 3, 592, 296, 0, 1522, 1540, 3, 76, 38, 0, 1523, 1524, 5, 192, 0, + 0, 1524, 1525, 5, 548, 0, 0, 1525, 1540, 3, 584, 292, 0, 1526, 1527, 5, + 369, 0, 0, 1527, 1540, 5, 1153, 0, 0, 1528, 1540, 7, 15, 0, 0, 1529, 1531, + 5, 877, 0, 0, 1530, 1532, 5, 1129, 0, 0, 1531, 1530, 1, 0, 0, 0, 1531, + 1532, 1, 0, 0, 0, 1532, 1533, 1, 0, 0, 0, 1533, 1540, 5, 1153, 0, 0, 1534, + 1536, 5, 1002, 0, 0, 1535, 1537, 5, 1129, 0, 0, 1536, 1535, 1, 0, 0, 0, + 1536, 1537, 1, 0, 0, 0, 1537, 1538, 1, 0, 0, 0, 1538, 1540, 5, 1153, 0, + 0, 1539, 1517, 1, 0, 0, 0, 1539, 1522, 1, 0, 0, 0, 1539, 1523, 1, 0, 0, + 0, 1539, 1526, 1, 0, 0, 0, 1539, 1528, 1, 0, 0, 0, 1539, 1529, 1, 0, 0, + 0, 1539, 1534, 1, 0, 0, 0, 1540, 79, 1, 0, 0, 0, 1541, 1543, 7, 16, 0, + 0, 1542, 1541, 1, 0, 0, 0, 1542, 1543, 1, 0, 0, 0, 1543, 1544, 1, 0, 0, + 0, 1544, 1545, 3, 584, 292, 0, 1545, 1546, 3, 604, 302, 0, 1546, 81, 1, + 0, 0, 0, 1547, 1548, 3, 584, 292, 0, 1548, 1549, 3, 604, 302, 0, 1549, + 83, 1, 0, 0, 0, 1550, 1551, 5, 369, 0, 0, 1551, 1574, 5, 1153, 0, 0, 1552, + 1553, 5, 469, 0, 0, 1553, 1574, 5, 160, 0, 0, 1554, 1556, 5, 114, 0, 0, + 1555, 1554, 1, 0, 0, 0, 1555, 1556, 1, 0, 0, 0, 1556, 1557, 1, 0, 0, 0, + 1557, 1574, 5, 47, 0, 0, 1558, 1559, 5, 382, 0, 0, 1559, 1569, 5, 160, + 0, 0, 1560, 1561, 5, 522, 0, 0, 1561, 1569, 5, 160, 0, 0, 1562, 1563, 5, + 135, 0, 0, 1563, 1564, 5, 160, 0, 0, 1564, 1569, 5, 389, 0, 0, 1565, 1566, + 5, 112, 0, 0, 1566, 1567, 5, 160, 0, 0, 1567, 1569, 5, 389, 0, 0, 1568, + 1558, 1, 0, 0, 0, 1568, 1560, 1, 0, 0, 0, 1568, 1562, 1, 0, 0, 0, 1568, + 1565, 1, 0, 0, 0, 1569, 1574, 1, 0, 0, 0, 1570, 1571, 5, 160, 0, 0, 1571, + 1572, 5, 607, 0, 0, 1572, 1574, 7, 11, 0, 0, 1573, 1550, 1, 0, 0, 0, 1573, + 1552, 1, 0, 0, 0, 1573, 1555, 1, 0, 0, 0, 1573, 1568, 1, 0, 0, 0, 1573, + 1570, 1, 0, 0, 0, 1574, 85, 1, 0, 0, 0, 1575, 1576, 5, 447, 0, 0, 1576, + 1590, 5, 1153, 0, 0, 1577, 1578, 5, 39, 0, 0, 1578, 1590, 5, 1153, 0, 0, + 1579, 1580, 5, 666, 0, 0, 1580, 1590, 5, 1153, 0, 0, 1581, 1582, 5, 552, + 0, 0, 1582, 1590, 5, 1153, 0, 0, 1583, 1584, 5, 618, 0, 0, 1584, 1590, + 5, 1153, 0, 0, 1585, 1586, 5, 543, 0, 0, 1586, 1590, 5, 1153, 0, 0, 1587, + 1588, 5, 558, 0, 0, 1588, 1590, 3, 590, 295, 0, 1589, 1575, 1, 0, 0, 0, + 1589, 1577, 1, 0, 0, 0, 1589, 1579, 1, 0, 0, 0, 1589, 1581, 1, 0, 0, 0, + 1589, 1583, 1, 0, 0, 0, 1589, 1585, 1, 0, 0, 0, 1589, 1587, 1, 0, 0, 0, + 1590, 87, 1, 0, 0, 0, 1591, 1592, 5, 1138, 0, 0, 1592, 1597, 3, 90, 45, + 0, 1593, 1594, 5, 1140, 0, 0, 1594, 1596, 3, 90, 45, 0, 1595, 1593, 1, + 0, 0, 0, 1596, 1599, 1, 0, 0, 0, 1597, 1595, 1, 0, 0, 0, 1597, 1598, 1, + 0, 0, 0, 1598, 1600, 1, 0, 0, 0, 1599, 1597, 1, 0, 0, 0, 1600, 1601, 5, + 1139, 0, 0, 1601, 89, 1, 0, 0, 0, 1602, 1603, 3, 556, 278, 0, 1603, 1604, + 3, 92, 46, 0, 1604, 1614, 1, 0, 0, 0, 1605, 1607, 3, 96, 48, 0, 1606, 1608, + 5, 114, 0, 0, 1607, 1606, 1, 0, 0, 0, 1607, 1608, 1, 0, 0, 0, 1608, 1610, + 1, 0, 0, 0, 1609, 1611, 5, 57, 0, 0, 1610, 1609, 1, 0, 0, 0, 1610, 1611, + 1, 0, 0, 0, 1611, 1614, 1, 0, 0, 0, 1612, 1614, 3, 104, 52, 0, 1613, 1602, + 1, 0, 0, 0, 1613, 1605, 1, 0, 0, 0, 1613, 1612, 1, 0, 0, 0, 1614, 91, 1, + 0, 0, 0, 1615, 1619, 3, 604, 302, 0, 1616, 1618, 3, 94, 47, 0, 1617, 1616, + 1, 0, 0, 0, 1618, 1621, 1, 0, 0, 0, 1619, 1617, 1, 0, 0, 0, 1619, 1620, + 1, 0, 0, 0, 1620, 1623, 1, 0, 0, 0, 1621, 1619, 1, 0, 0, 0, 1622, 1624, + 5, 114, 0, 0, 1623, 1622, 1, 0, 0, 0, 1623, 1624, 1, 0, 0, 0, 1624, 1626, + 1, 0, 0, 0, 1625, 1627, 5, 57, 0, 0, 1626, 1625, 1, 0, 0, 0, 1626, 1627, + 1, 0, 0, 0, 1627, 93, 1, 0, 0, 0, 1628, 1682, 3, 600, 300, 0, 1629, 1630, + 5, 42, 0, 0, 1630, 1682, 3, 634, 317, 0, 1631, 1682, 5, 674, 0, 0, 1632, + 1682, 5, 460, 0, 0, 1633, 1638, 5, 343, 0, 0, 1634, 1635, 5, 118, 0, 0, + 1635, 1636, 5, 184, 0, 0, 1636, 1638, 3, 636, 318, 0, 1637, 1633, 1, 0, + 0, 0, 1637, 1634, 1, 0, 0, 0, 1638, 1682, 1, 0, 0, 0, 1639, 1641, 5, 130, + 0, 0, 1640, 1639, 1, 0, 0, 0, 1640, 1641, 1, 0, 0, 0, 1641, 1642, 1, 0, + 0, 0, 1642, 1682, 5, 91, 0, 0, 1643, 1645, 5, 181, 0, 0, 1644, 1646, 5, + 91, 0, 0, 1645, 1644, 1, 0, 0, 0, 1645, 1646, 1, 0, 0, 0, 1646, 1682, 1, + 0, 0, 0, 1647, 1648, 5, 369, 0, 0, 1648, 1682, 5, 1153, 0, 0, 1649, 1650, + 5, 367, 0, 0, 1650, 1682, 7, 17, 0, 0, 1651, 1652, 5, 637, 0, 0, 1652, + 1682, 7, 18, 0, 0, 1653, 1682, 3, 98, 49, 0, 1654, 1655, 5, 27, 0, 0, 1655, + 1682, 3, 570, 285, 0, 1656, 1657, 5, 70, 0, 0, 1657, 1659, 5, 8, 0, 0, + 1658, 1656, 1, 0, 0, 0, 1658, 1659, 1, 0, 0, 0, 1659, 1660, 1, 0, 0, 0, + 1660, 1661, 5, 12, 0, 0, 1661, 1662, 5, 1138, 0, 0, 1662, 1663, 3, 688, + 344, 0, 1663, 1665, 5, 1139, 0, 0, 1664, 1666, 7, 19, 0, 0, 1665, 1664, + 1, 0, 0, 0, 1665, 1666, 1, 0, 0, 0, 1666, 1682, 1, 0, 0, 0, 1667, 1668, + 5, 239, 0, 0, 1668, 1669, 5, 42, 0, 0, 1669, 1682, 5, 670, 0, 0, 1670, + 1672, 5, 30, 0, 0, 1671, 1673, 3, 584, 292, 0, 1672, 1671, 1, 0, 0, 0, + 1672, 1673, 1, 0, 0, 0, 1673, 1675, 1, 0, 0, 0, 1674, 1670, 1, 0, 0, 0, + 1674, 1675, 1, 0, 0, 0, 1675, 1676, 1, 0, 0, 0, 1676, 1677, 5, 26, 0, 0, + 1677, 1678, 5, 1138, 0, 0, 1678, 1679, 3, 688, 344, 0, 1679, 1680, 5, 1139, + 0, 0, 1680, 1682, 1, 0, 0, 0, 1681, 1628, 1, 0, 0, 0, 1681, 1629, 1, 0, + 0, 0, 1681, 1631, 1, 0, 0, 0, 1681, 1632, 1, 0, 0, 0, 1681, 1637, 1, 0, + 0, 0, 1681, 1640, 1, 0, 0, 0, 1681, 1643, 1, 0, 0, 0, 1681, 1647, 1, 0, + 0, 0, 1681, 1649, 1, 0, 0, 0, 1681, 1651, 1, 0, 0, 0, 1681, 1653, 1, 0, + 0, 0, 1681, 1654, 1, 0, 0, 0, 1681, 1658, 1, 0, 0, 0, 1681, 1667, 1, 0, + 0, 0, 1681, 1674, 1, 0, 0, 0, 1682, 95, 1, 0, 0, 0, 1683, 1685, 5, 30, + 0, 0, 1684, 1686, 3, 584, 292, 0, 1685, 1684, 1, 0, 0, 0, 1685, 1686, 1, + 0, 0, 0, 1686, 1688, 1, 0, 0, 0, 1687, 1683, 1, 0, 0, 0, 1687, 1688, 1, + 0, 0, 0, 1688, 1689, 1, 0, 0, 0, 1689, 1690, 5, 130, 0, 0, 1690, 1692, + 5, 91, 0, 0, 1691, 1693, 3, 584, 292, 0, 1692, 1691, 1, 0, 0, 0, 1692, + 1693, 1, 0, 0, 0, 1693, 1695, 1, 0, 0, 0, 1694, 1696, 3, 76, 38, 0, 1695, + 1694, 1, 0, 0, 0, 1695, 1696, 1, 0, 0, 0, 1696, 1697, 1, 0, 0, 0, 1697, + 1701, 3, 622, 311, 0, 1698, 1700, 3, 78, 39, 0, 1699, 1698, 1, 0, 0, 0, + 1700, 1703, 1, 0, 0, 0, 1701, 1699, 1, 0, 0, 0, 1701, 1702, 1, 0, 0, 0, + 1702, 1753, 1, 0, 0, 0, 1703, 1701, 1, 0, 0, 0, 1704, 1706, 5, 30, 0, 0, + 1705, 1707, 3, 584, 292, 0, 1706, 1705, 1, 0, 0, 0, 1706, 1707, 1, 0, 0, + 0, 1707, 1709, 1, 0, 0, 0, 1708, 1704, 1, 0, 0, 0, 1708, 1709, 1, 0, 0, + 0, 1709, 1710, 1, 0, 0, 0, 1710, 1712, 5, 181, 0, 0, 1711, 1713, 7, 20, + 0, 0, 1712, 1711, 1, 0, 0, 0, 1712, 1713, 1, 0, 0, 0, 1713, 1715, 1, 0, + 0, 0, 1714, 1716, 3, 584, 292, 0, 1715, 1714, 1, 0, 0, 0, 1715, 1716, 1, + 0, 0, 0, 1716, 1718, 1, 0, 0, 0, 1717, 1719, 3, 76, 38, 0, 1718, 1717, + 1, 0, 0, 0, 1718, 1719, 1, 0, 0, 0, 1719, 1720, 1, 0, 0, 0, 1720, 1724, + 3, 622, 311, 0, 1721, 1723, 3, 78, 39, 0, 1722, 1721, 1, 0, 0, 0, 1723, + 1726, 1, 0, 0, 0, 1724, 1722, 1, 0, 0, 0, 1724, 1725, 1, 0, 0, 0, 1725, + 1753, 1, 0, 0, 0, 1726, 1724, 1, 0, 0, 0, 1727, 1729, 5, 30, 0, 0, 1728, + 1730, 3, 584, 292, 0, 1729, 1728, 1, 0, 0, 0, 1729, 1730, 1, 0, 0, 0, 1730, + 1732, 1, 0, 0, 0, 1731, 1727, 1, 0, 0, 0, 1731, 1732, 1, 0, 0, 0, 1732, + 1733, 1, 0, 0, 0, 1733, 1734, 5, 67, 0, 0, 1734, 1736, 5, 91, 0, 0, 1735, + 1737, 3, 584, 292, 0, 1736, 1735, 1, 0, 0, 0, 1736, 1737, 1, 0, 0, 0, 1737, + 1738, 1, 0, 0, 0, 1738, 1739, 3, 622, 311, 0, 1739, 1740, 3, 98, 49, 0, + 1740, 1753, 1, 0, 0, 0, 1741, 1743, 5, 30, 0, 0, 1742, 1744, 3, 584, 292, + 0, 1743, 1742, 1, 0, 0, 0, 1743, 1744, 1, 0, 0, 0, 1744, 1746, 1, 0, 0, + 0, 1745, 1741, 1, 0, 0, 0, 1745, 1746, 1, 0, 0, 0, 1746, 1747, 1, 0, 0, + 0, 1747, 1748, 5, 26, 0, 0, 1748, 1749, 5, 1138, 0, 0, 1749, 1750, 3, 688, + 344, 0, 1750, 1751, 5, 1139, 0, 0, 1751, 1753, 1, 0, 0, 0, 1752, 1687, + 1, 0, 0, 0, 1752, 1708, 1, 0, 0, 0, 1752, 1731, 1, 0, 0, 0, 1752, 1745, + 1, 0, 0, 0, 1753, 97, 1, 0, 0, 0, 1754, 1755, 5, 136, 0, 0, 1755, 1757, + 3, 552, 276, 0, 1756, 1758, 3, 622, 311, 0, 1757, 1756, 1, 0, 0, 0, 1757, + 1758, 1, 0, 0, 0, 1758, 1761, 1, 0, 0, 0, 1759, 1760, 5, 109, 0, 0, 1760, + 1762, 7, 21, 0, 0, 1761, 1759, 1, 0, 0, 0, 1761, 1762, 1, 0, 0, 0, 1762, + 1764, 1, 0, 0, 0, 1763, 1765, 3, 100, 50, 0, 1764, 1763, 1, 0, 0, 0, 1764, + 1765, 1, 0, 0, 0, 1765, 99, 1, 0, 0, 0, 1766, 1767, 5, 118, 0, 0, 1767, + 1768, 5, 44, 0, 0, 1768, 1772, 3, 102, 51, 0, 1769, 1770, 5, 118, 0, 0, + 1770, 1771, 5, 184, 0, 0, 1771, 1773, 3, 102, 51, 0, 1772, 1769, 1, 0, + 0, 0, 1772, 1773, 1, 0, 0, 0, 1773, 1783, 1, 0, 0, 0, 1774, 1775, 5, 118, + 0, 0, 1775, 1776, 5, 184, 0, 0, 1776, 1780, 3, 102, 51, 0, 1777, 1778, + 5, 118, 0, 0, 1778, 1779, 5, 44, 0, 0, 1779, 1781, 3, 102, 51, 0, 1780, + 1777, 1, 0, 0, 0, 1780, 1781, 1, 0, 0, 0, 1781, 1783, 1, 0, 0, 0, 1782, + 1766, 1, 0, 0, 0, 1782, 1774, 1, 0, 0, 0, 1783, 101, 1, 0, 0, 0, 1784, + 1793, 5, 144, 0, 0, 1785, 1793, 5, 21, 0, 0, 1786, 1787, 5, 153, 0, 0, + 1787, 1793, 5, 116, 0, 0, 1788, 1789, 5, 522, 0, 0, 1789, 1793, 5, 334, + 0, 0, 1790, 1791, 5, 153, 0, 0, 1791, 1793, 5, 42, 0, 0, 1792, 1784, 1, + 0, 0, 0, 1792, 1785, 1, 0, 0, 0, 1792, 1786, 1, 0, 0, 0, 1792, 1788, 1, + 0, 0, 0, 1792, 1790, 1, 0, 0, 0, 1793, 103, 1, 0, 0, 0, 1794, 1796, 7, + 20, 0, 0, 1795, 1797, 3, 584, 292, 0, 1796, 1795, 1, 0, 0, 0, 1796, 1797, + 1, 0, 0, 0, 1797, 1799, 1, 0, 0, 0, 1798, 1800, 3, 76, 38, 0, 1799, 1798, + 1, 0, 0, 0, 1799, 1800, 1, 0, 0, 0, 1800, 1801, 1, 0, 0, 0, 1801, 1805, + 3, 622, 311, 0, 1802, 1804, 3, 78, 39, 0, 1803, 1802, 1, 0, 0, 0, 1804, + 1807, 1, 0, 0, 0, 1805, 1803, 1, 0, 0, 0, 1805, 1806, 1, 0, 0, 0, 1806, + 1823, 1, 0, 0, 0, 1807, 1805, 1, 0, 0, 0, 1808, 1810, 7, 22, 0, 0, 1809, + 1811, 7, 20, 0, 0, 1810, 1809, 1, 0, 0, 0, 1810, 1811, 1, 0, 0, 0, 1811, + 1813, 1, 0, 0, 0, 1812, 1814, 3, 584, 292, 0, 1813, 1812, 1, 0, 0, 0, 1813, + 1814, 1, 0, 0, 0, 1814, 1815, 1, 0, 0, 0, 1815, 1819, 3, 622, 311, 0, 1816, + 1818, 3, 78, 39, 0, 1817, 1816, 1, 0, 0, 0, 1818, 1821, 1, 0, 0, 0, 1819, + 1817, 1, 0, 0, 0, 1819, 1820, 1, 0, 0, 0, 1820, 1823, 1, 0, 0, 0, 1821, + 1819, 1, 0, 0, 0, 1822, 1794, 1, 0, 0, 0, 1822, 1808, 1, 0, 0, 0, 1823, + 105, 1, 0, 0, 0, 1824, 1826, 5, 410, 0, 0, 1825, 1827, 5, 1129, 0, 0, 1826, + 1825, 1, 0, 0, 0, 1826, 1827, 1, 0, 0, 0, 1827, 1829, 1, 0, 0, 0, 1828, + 1830, 3, 572, 286, 0, 1829, 1828, 1, 0, 0, 0, 1829, 1830, 1, 0, 0, 0, 1830, + 2010, 1, 0, 0, 0, 1831, 1833, 5, 877, 0, 0, 1832, 1834, 5, 1129, 0, 0, + 1833, 1832, 1, 0, 0, 0, 1833, 1834, 1, 0, 0, 0, 1834, 1835, 1, 0, 0, 0, + 1835, 2010, 5, 1153, 0, 0, 1836, 1838, 5, 342, 0, 0, 1837, 1839, 5, 1129, + 0, 0, 1838, 1837, 1, 0, 0, 0, 1838, 1839, 1, 0, 0, 0, 1839, 1840, 1, 0, + 0, 0, 1840, 2010, 3, 590, 295, 0, 1841, 1843, 5, 343, 0, 0, 1842, 1844, + 5, 1129, 0, 0, 1843, 1842, 1, 0, 0, 0, 1843, 1844, 1, 0, 0, 0, 1844, 1845, + 1, 0, 0, 0, 1845, 2010, 3, 590, 295, 0, 1846, 1848, 5, 344, 0, 0, 1847, + 1849, 5, 1129, 0, 0, 1848, 1847, 1, 0, 0, 0, 1848, 1849, 1, 0, 0, 0, 1849, + 1850, 1, 0, 0, 0, 1850, 2010, 3, 590, 295, 0, 1851, 1853, 5, 42, 0, 0, + 1852, 1851, 1, 0, 0, 0, 1852, 1853, 1, 0, 0, 0, 1853, 1854, 1, 0, 0, 0, + 1854, 1856, 3, 60, 30, 0, 1855, 1857, 5, 1129, 0, 0, 1856, 1855, 1, 0, + 0, 0, 1856, 1857, 1, 0, 0, 0, 1857, 1860, 1, 0, 0, 0, 1858, 1861, 3, 568, + 284, 0, 1859, 1861, 5, 42, 0, 0, 1860, 1858, 1, 0, 0, 0, 1860, 1859, 1, + 0, 0, 0, 1861, 2010, 1, 0, 0, 0, 1862, 1864, 7, 23, 0, 0, 1863, 1865, 5, + 1129, 0, 0, 1864, 1863, 1, 0, 0, 0, 1864, 1865, 1, 0, 0, 0, 1865, 1866, + 1, 0, 0, 0, 1866, 2010, 7, 24, 0, 0, 1867, 1869, 5, 42, 0, 0, 1868, 1867, + 1, 0, 0, 0, 1868, 1869, 1, 0, 0, 0, 1869, 1870, 1, 0, 0, 0, 1870, 1872, + 5, 27, 0, 0, 1871, 1873, 5, 1129, 0, 0, 1872, 1871, 1, 0, 0, 0, 1872, 1873, + 1, 0, 0, 0, 1873, 1874, 1, 0, 0, 0, 1874, 2010, 3, 570, 285, 0, 1875, 1877, + 5, 369, 0, 0, 1876, 1878, 5, 1129, 0, 0, 1877, 1876, 1, 0, 0, 0, 1877, + 1878, 1, 0, 0, 0, 1878, 1879, 1, 0, 0, 0, 1879, 2010, 5, 1153, 0, 0, 1880, + 1882, 5, 374, 0, 0, 1881, 1883, 5, 1129, 0, 0, 1882, 1881, 1, 0, 0, 0, + 1882, 1883, 1, 0, 0, 0, 1883, 1884, 1, 0, 0, 0, 1884, 2010, 7, 25, 0, 0, + 1885, 1887, 5, 377, 0, 0, 1886, 1888, 5, 1129, 0, 0, 1887, 1886, 1, 0, + 0, 0, 1887, 1888, 1, 0, 0, 0, 1888, 1889, 1, 0, 0, 0, 1889, 2010, 5, 1153, + 0, 0, 1890, 1891, 7, 26, 0, 0, 1891, 1893, 5, 396, 0, 0, 1892, 1894, 5, + 1129, 0, 0, 1893, 1892, 1, 0, 0, 0, 1893, 1894, 1, 0, 0, 0, 1894, 1895, + 1, 0, 0, 0, 1895, 2010, 5, 1153, 0, 0, 1896, 1898, 5, 394, 0, 0, 1897, + 1899, 5, 1129, 0, 0, 1898, 1897, 1, 0, 0, 0, 1898, 1899, 1, 0, 0, 0, 1899, + 1900, 1, 0, 0, 0, 1900, 2010, 7, 24, 0, 0, 1901, 1903, 5, 406, 0, 0, 1902, + 1904, 5, 1129, 0, 0, 1903, 1902, 1, 0, 0, 0, 1903, 1904, 1, 0, 0, 0, 1904, + 1905, 1, 0, 0, 0, 1905, 2010, 5, 1153, 0, 0, 1906, 1908, 7, 27, 0, 0, 1907, + 1909, 5, 1129, 0, 0, 1908, 1907, 1, 0, 0, 0, 1908, 1909, 1, 0, 0, 0, 1909, + 1910, 1, 0, 0, 0, 1910, 2010, 7, 24, 0, 0, 1911, 1913, 7, 28, 0, 0, 1912, + 1914, 5, 1129, 0, 0, 1913, 1912, 1, 0, 0, 0, 1913, 1914, 1, 0, 0, 0, 1914, + 1915, 1, 0, 0, 0, 1915, 2010, 3, 590, 295, 0, 1916, 1918, 5, 407, 0, 0, + 1917, 1919, 5, 1129, 0, 0, 1918, 1917, 1, 0, 0, 0, 1918, 1919, 1, 0, 0, + 0, 1919, 1920, 1, 0, 0, 0, 1920, 2010, 3, 590, 295, 0, 1921, 1922, 5, 81, + 0, 0, 1922, 1924, 5, 396, 0, 0, 1923, 1925, 5, 1129, 0, 0, 1924, 1923, + 1, 0, 0, 0, 1924, 1925, 1, 0, 0, 0, 1925, 1926, 1, 0, 0, 0, 1926, 2010, + 5, 1153, 0, 0, 1927, 1929, 5, 456, 0, 0, 1928, 1930, 5, 1129, 0, 0, 1929, + 1928, 1, 0, 0, 0, 1929, 1930, 1, 0, 0, 0, 1930, 1931, 1, 0, 0, 0, 1931, + 2010, 7, 29, 0, 0, 1932, 1934, 5, 468, 0, 0, 1933, 1935, 5, 1129, 0, 0, + 1934, 1933, 1, 0, 0, 0, 1934, 1935, 1, 0, 0, 0, 1935, 1936, 1, 0, 0, 0, + 1936, 2010, 3, 592, 296, 0, 1937, 1939, 5, 501, 0, 0, 1938, 1940, 5, 1129, + 0, 0, 1939, 1938, 1, 0, 0, 0, 1939, 1940, 1, 0, 0, 0, 1940, 1941, 1, 0, + 0, 0, 1941, 2010, 3, 590, 295, 0, 1942, 1944, 5, 511, 0, 0, 1943, 1945, + 5, 1129, 0, 0, 1944, 1943, 1, 0, 0, 0, 1944, 1945, 1, 0, 0, 0, 1945, 1946, + 1, 0, 0, 0, 1946, 2010, 3, 590, 295, 0, 1947, 1949, 5, 544, 0, 0, 1948, + 1950, 5, 1129, 0, 0, 1949, 1948, 1, 0, 0, 0, 1949, 1950, 1, 0, 0, 0, 1950, + 1951, 1, 0, 0, 0, 1951, 2010, 7, 13, 0, 0, 1952, 1954, 5, 552, 0, 0, 1953, + 1955, 5, 1129, 0, 0, 1954, 1953, 1, 0, 0, 0, 1954, 1955, 1, 0, 0, 0, 1955, + 1956, 1, 0, 0, 0, 1956, 2010, 5, 1153, 0, 0, 1957, 1959, 5, 603, 0, 0, + 1958, 1960, 5, 1129, 0, 0, 1959, 1958, 1, 0, 0, 0, 1959, 1960, 1, 0, 0, + 0, 1960, 1961, 1, 0, 0, 0, 1961, 2010, 7, 30, 0, 0, 1962, 1963, 5, 630, + 0, 0, 1963, 2010, 5, 654, 0, 0, 1964, 1966, 5, 1002, 0, 0, 1965, 1967, + 5, 1129, 0, 0, 1966, 1965, 1, 0, 0, 0, 1966, 1967, 1, 0, 0, 0, 1967, 1968, + 1, 0, 0, 0, 1968, 2010, 5, 1153, 0, 0, 1969, 1971, 5, 632, 0, 0, 1970, + 1972, 5, 1129, 0, 0, 1971, 1970, 1, 0, 0, 0, 1971, 1972, 1, 0, 0, 0, 1972, + 1973, 1, 0, 0, 0, 1973, 2010, 7, 13, 0, 0, 1974, 1976, 5, 633, 0, 0, 1975, + 1977, 5, 1129, 0, 0, 1976, 1975, 1, 0, 0, 0, 1976, 1977, 1, 0, 0, 0, 1977, + 1978, 1, 0, 0, 0, 1978, 2010, 7, 13, 0, 0, 1979, 1981, 5, 634, 0, 0, 1980, + 1982, 5, 1129, 0, 0, 1981, 1980, 1, 0, 0, 0, 1981, 1982, 1, 0, 0, 0, 1982, + 1985, 1, 0, 0, 0, 1983, 1986, 5, 42, 0, 0, 1984, 1986, 3, 590, 295, 0, + 1985, 1983, 1, 0, 0, 0, 1985, 1984, 1, 0, 0, 0, 1986, 2010, 1, 0, 0, 0, + 1987, 1988, 5, 648, 0, 0, 1988, 1990, 3, 584, 292, 0, 1989, 1991, 3, 110, + 55, 0, 1990, 1989, 1, 0, 0, 0, 1990, 1991, 1, 0, 0, 0, 1991, 2010, 1, 0, + 0, 0, 1992, 1993, 5, 649, 0, 0, 1993, 1994, 5, 1129, 0, 0, 1994, 2010, + 3, 108, 54, 0, 1995, 2010, 3, 110, 55, 0, 1996, 1998, 5, 655, 0, 0, 1997, + 1999, 5, 1129, 0, 0, 1998, 1997, 1, 0, 0, 0, 1998, 1999, 1, 0, 0, 0, 1999, + 2000, 1, 0, 0, 0, 2000, 2010, 7, 24, 0, 0, 2001, 2003, 5, 180, 0, 0, 2002, + 2004, 5, 1129, 0, 0, 2003, 2002, 1, 0, 0, 0, 2003, 2004, 1, 0, 0, 0, 2004, + 2005, 1, 0, 0, 0, 2005, 2006, 5, 1138, 0, 0, 2006, 2007, 3, 620, 310, 0, + 2007, 2008, 5, 1139, 0, 0, 2008, 2010, 1, 0, 0, 0, 2009, 1824, 1, 0, 0, + 0, 2009, 1831, 1, 0, 0, 0, 2009, 1836, 1, 0, 0, 0, 2009, 1841, 1, 0, 0, + 0, 2009, 1846, 1, 0, 0, 0, 2009, 1852, 1, 0, 0, 0, 2009, 1862, 1, 0, 0, + 0, 2009, 1868, 1, 0, 0, 0, 2009, 1875, 1, 0, 0, 0, 2009, 1880, 1, 0, 0, + 0, 2009, 1885, 1, 0, 0, 0, 2009, 1890, 1, 0, 0, 0, 2009, 1896, 1, 0, 0, + 0, 2009, 1901, 1, 0, 0, 0, 2009, 1906, 1, 0, 0, 0, 2009, 1911, 1, 0, 0, + 0, 2009, 1916, 1, 0, 0, 0, 2009, 1921, 1, 0, 0, 0, 2009, 1927, 1, 0, 0, + 0, 2009, 1932, 1, 0, 0, 0, 2009, 1937, 1, 0, 0, 0, 2009, 1942, 1, 0, 0, + 0, 2009, 1947, 1, 0, 0, 0, 2009, 1952, 1, 0, 0, 0, 2009, 1957, 1, 0, 0, + 0, 2009, 1962, 1, 0, 0, 0, 2009, 1964, 1, 0, 0, 0, 2009, 1969, 1, 0, 0, + 0, 2009, 1974, 1, 0, 0, 0, 2009, 1979, 1, 0, 0, 0, 2009, 1987, 1, 0, 0, + 0, 2009, 1992, 1, 0, 0, 0, 2009, 1995, 1, 0, 0, 0, 2009, 1996, 1, 0, 0, + 0, 2009, 2001, 1, 0, 0, 0, 2010, 107, 1, 0, 0, 0, 2011, 2012, 7, 31, 0, + 0, 2012, 109, 1, 0, 0, 0, 2013, 2014, 5, 637, 0, 0, 2014, 2015, 7, 18, + 0, 0, 2015, 111, 1, 0, 0, 0, 2016, 2017, 5, 129, 0, 0, 2017, 2018, 5, 19, + 0, 0, 2018, 2021, 3, 114, 57, 0, 2019, 2020, 5, 551, 0, 0, 2020, 2022, + 3, 590, 295, 0, 2021, 2019, 1, 0, 0, 0, 2021, 2022, 1, 0, 0, 0, 2022, 2030, + 1, 0, 0, 0, 2023, 2024, 5, 642, 0, 0, 2024, 2025, 5, 19, 0, 0, 2025, 2028, + 3, 116, 58, 0, 2026, 2027, 5, 643, 0, 0, 2027, 2029, 3, 590, 295, 0, 2028, + 2026, 1, 0, 0, 0, 2028, 2029, 1, 0, 0, 0, 2029, 2031, 1, 0, 0, 0, 2030, + 2023, 1, 0, 0, 0, 2030, 2031, 1, 0, 0, 0, 2031, 2043, 1, 0, 0, 0, 2032, + 2033, 5, 1138, 0, 0, 2033, 2038, 3, 118, 59, 0, 2034, 2035, 5, 1140, 0, + 0, 2035, 2037, 3, 118, 59, 0, 2036, 2034, 1, 0, 0, 0, 2037, 2040, 1, 0, + 0, 0, 2038, 2036, 1, 0, 0, 0, 2038, 2039, 1, 0, 0, 0, 2039, 2041, 1, 0, + 0, 0, 2040, 2038, 1, 0, 0, 0, 2041, 2042, 5, 1139, 0, 0, 2042, 2044, 1, + 0, 0, 0, 2043, 2032, 1, 0, 0, 0, 2043, 2044, 1, 0, 0, 0, 2044, 113, 1, + 0, 0, 0, 2045, 2047, 5, 100, 0, 0, 2046, 2045, 1, 0, 0, 0, 2046, 2047, + 1, 0, 0, 0, 2047, 2048, 1, 0, 0, 0, 2048, 2049, 5, 444, 0, 0, 2049, 2050, + 5, 1138, 0, 0, 2050, 2051, 3, 688, 344, 0, 2051, 2052, 5, 1139, 0, 0, 2052, + 2092, 1, 0, 0, 0, 2053, 2055, 5, 100, 0, 0, 2054, 2053, 1, 0, 0, 0, 2054, + 2055, 1, 0, 0, 0, 2055, 2056, 1, 0, 0, 0, 2056, 2060, 5, 91, 0, 0, 2057, + 2058, 5, 337, 0, 0, 2058, 2059, 5, 1129, 0, 0, 2059, 2061, 7, 32, 0, 0, + 2060, 2057, 1, 0, 0, 0, 2060, 2061, 1, 0, 0, 0, 2061, 2062, 1, 0, 0, 0, + 2062, 2064, 5, 1138, 0, 0, 2063, 2065, 3, 616, 308, 0, 2064, 2063, 1, 0, + 0, 0, 2064, 2065, 1, 0, 0, 0, 2065, 2066, 1, 0, 0, 0, 2066, 2092, 5, 1139, + 0, 0, 2067, 2077, 5, 133, 0, 0, 2068, 2069, 5, 1138, 0, 0, 2069, 2070, + 3, 688, 344, 0, 2070, 2071, 5, 1139, 0, 0, 2071, 2078, 1, 0, 0, 0, 2072, + 2073, 5, 366, 0, 0, 2073, 2074, 5, 1138, 0, 0, 2074, 2075, 3, 616, 308, + 0, 2075, 2076, 5, 1139, 0, 0, 2076, 2078, 1, 0, 0, 0, 2077, 2068, 1, 0, + 0, 0, 2077, 2072, 1, 0, 0, 0, 2078, 2092, 1, 0, 0, 0, 2079, 2089, 5, 474, + 0, 0, 2080, 2081, 5, 1138, 0, 0, 2081, 2082, 3, 688, 344, 0, 2082, 2083, + 5, 1139, 0, 0, 2083, 2090, 1, 0, 0, 0, 2084, 2085, 5, 366, 0, 0, 2085, + 2086, 5, 1138, 0, 0, 2086, 2087, 3, 616, 308, 0, 2087, 2088, 5, 1139, 0, + 0, 2088, 2090, 1, 0, 0, 0, 2089, 2080, 1, 0, 0, 0, 2089, 2084, 1, 0, 0, + 0, 2090, 2092, 1, 0, 0, 0, 2091, 2046, 1, 0, 0, 0, 2091, 2054, 1, 0, 0, + 0, 2091, 2067, 1, 0, 0, 0, 2091, 2079, 1, 0, 0, 0, 2092, 115, 1, 0, 0, + 0, 2093, 2095, 5, 100, 0, 0, 2094, 2093, 1, 0, 0, 0, 2094, 2095, 1, 0, + 0, 0, 2095, 2096, 1, 0, 0, 0, 2096, 2097, 5, 444, 0, 0, 2097, 2098, 5, + 1138, 0, 0, 2098, 2099, 3, 688, 344, 0, 2099, 2100, 5, 1139, 0, 0, 2100, + 2115, 1, 0, 0, 0, 2101, 2103, 5, 100, 0, 0, 2102, 2101, 1, 0, 0, 0, 2102, + 2103, 1, 0, 0, 0, 2103, 2104, 1, 0, 0, 0, 2104, 2108, 5, 91, 0, 0, 2105, + 2106, 5, 337, 0, 0, 2106, 2107, 5, 1129, 0, 0, 2107, 2109, 7, 32, 0, 0, + 2108, 2105, 1, 0, 0, 0, 2108, 2109, 1, 0, 0, 0, 2109, 2110, 1, 0, 0, 0, + 2110, 2111, 5, 1138, 0, 0, 2111, 2112, 3, 616, 308, 0, 2112, 2113, 5, 1139, + 0, 0, 2113, 2115, 1, 0, 0, 0, 2114, 2094, 1, 0, 0, 0, 2114, 2102, 1, 0, + 0, 0, 2115, 117, 1, 0, 0, 0, 2116, 2117, 5, 129, 0, 0, 2117, 2118, 3, 584, + 292, 0, 2118, 2119, 5, 188, 0, 0, 2119, 2120, 5, 472, 0, 0, 2120, 2121, + 5, 652, 0, 0, 2121, 2122, 5, 1138, 0, 0, 2122, 2127, 3, 120, 60, 0, 2123, + 2124, 5, 1140, 0, 0, 2124, 2126, 3, 120, 60, 0, 2125, 2123, 1, 0, 0, 0, + 2126, 2129, 1, 0, 0, 0, 2127, 2125, 1, 0, 0, 0, 2127, 2128, 1, 0, 0, 0, + 2128, 2130, 1, 0, 0, 0, 2129, 2127, 1, 0, 0, 0, 2130, 2134, 5, 1139, 0, + 0, 2131, 2133, 3, 126, 63, 0, 2132, 2131, 1, 0, 0, 0, 2133, 2136, 1, 0, + 0, 0, 2134, 2132, 1, 0, 0, 0, 2134, 2135, 1, 0, 0, 0, 2135, 2148, 1, 0, + 0, 0, 2136, 2134, 1, 0, 0, 0, 2137, 2138, 5, 1138, 0, 0, 2138, 2143, 3, + 124, 62, 0, 2139, 2140, 5, 1140, 0, 0, 2140, 2142, 3, 124, 62, 0, 2141, + 2139, 1, 0, 0, 0, 2142, 2145, 1, 0, 0, 0, 2143, 2141, 1, 0, 0, 0, 2143, + 2144, 1, 0, 0, 0, 2144, 2146, 1, 0, 0, 0, 2145, 2143, 1, 0, 0, 0, 2146, + 2147, 5, 1139, 0, 0, 2147, 2149, 1, 0, 0, 0, 2148, 2137, 1, 0, 0, 0, 2148, + 2149, 1, 0, 0, 0, 2149, 2263, 1, 0, 0, 0, 2150, 2151, 5, 129, 0, 0, 2151, + 2152, 3, 584, 292, 0, 2152, 2153, 5, 188, 0, 0, 2153, 2154, 5, 472, 0, + 0, 2154, 2155, 5, 652, 0, 0, 2155, 2159, 3, 120, 60, 0, 2156, 2158, 3, + 126, 63, 0, 2157, 2156, 1, 0, 0, 0, 2158, 2161, 1, 0, 0, 0, 2159, 2157, + 1, 0, 0, 0, 2159, 2160, 1, 0, 0, 0, 2160, 2173, 1, 0, 0, 0, 2161, 2159, + 1, 0, 0, 0, 2162, 2163, 5, 1138, 0, 0, 2163, 2168, 3, 124, 62, 0, 2164, + 2165, 5, 1140, 0, 0, 2165, 2167, 3, 124, 62, 0, 2166, 2164, 1, 0, 0, 0, + 2167, 2170, 1, 0, 0, 0, 2168, 2166, 1, 0, 0, 0, 2168, 2169, 1, 0, 0, 0, + 2169, 2171, 1, 0, 0, 0, 2170, 2168, 1, 0, 0, 0, 2171, 2172, 5, 1139, 0, + 0, 2172, 2174, 1, 0, 0, 0, 2173, 2162, 1, 0, 0, 0, 2173, 2174, 1, 0, 0, + 0, 2174, 2263, 1, 0, 0, 0, 2175, 2176, 5, 129, 0, 0, 2176, 2177, 3, 584, + 292, 0, 2177, 2178, 5, 188, 0, 0, 2178, 2179, 5, 80, 0, 0, 2179, 2180, + 5, 1138, 0, 0, 2180, 2185, 3, 120, 60, 0, 2181, 2182, 5, 1140, 0, 0, 2182, + 2184, 3, 120, 60, 0, 2183, 2181, 1, 0, 0, 0, 2184, 2187, 1, 0, 0, 0, 2185, + 2183, 1, 0, 0, 0, 2185, 2186, 1, 0, 0, 0, 2186, 2188, 1, 0, 0, 0, 2187, + 2185, 1, 0, 0, 0, 2188, 2192, 5, 1139, 0, 0, 2189, 2191, 3, 126, 63, 0, + 2190, 2189, 1, 0, 0, 0, 2191, 2194, 1, 0, 0, 0, 2192, 2190, 1, 0, 0, 0, + 2192, 2193, 1, 0, 0, 0, 2193, 2206, 1, 0, 0, 0, 2194, 2192, 1, 0, 0, 0, + 2195, 2196, 5, 1138, 0, 0, 2196, 2201, 3, 124, 62, 0, 2197, 2198, 5, 1140, + 0, 0, 2198, 2200, 3, 124, 62, 0, 2199, 2197, 1, 0, 0, 0, 2200, 2203, 1, + 0, 0, 0, 2201, 2199, 1, 0, 0, 0, 2201, 2202, 1, 0, 0, 0, 2202, 2204, 1, + 0, 0, 0, 2203, 2201, 1, 0, 0, 0, 2204, 2205, 5, 1139, 0, 0, 2205, 2207, + 1, 0, 0, 0, 2206, 2195, 1, 0, 0, 0, 2206, 2207, 1, 0, 0, 0, 2207, 2263, + 1, 0, 0, 0, 2208, 2209, 5, 129, 0, 0, 2209, 2210, 3, 584, 292, 0, 2210, + 2211, 5, 188, 0, 0, 2211, 2212, 5, 80, 0, 0, 2212, 2213, 5, 1138, 0, 0, + 2213, 2218, 3, 122, 61, 0, 2214, 2215, 5, 1140, 0, 0, 2215, 2217, 3, 122, + 61, 0, 2216, 2214, 1, 0, 0, 0, 2217, 2220, 1, 0, 0, 0, 2218, 2216, 1, 0, + 0, 0, 2218, 2219, 1, 0, 0, 0, 2219, 2221, 1, 0, 0, 0, 2220, 2218, 1, 0, + 0, 0, 2221, 2225, 5, 1139, 0, 0, 2222, 2224, 3, 126, 63, 0, 2223, 2222, + 1, 0, 0, 0, 2224, 2227, 1, 0, 0, 0, 2225, 2223, 1, 0, 0, 0, 2225, 2226, + 1, 0, 0, 0, 2226, 2239, 1, 0, 0, 0, 2227, 2225, 1, 0, 0, 0, 2228, 2229, + 5, 1138, 0, 0, 2229, 2234, 3, 124, 62, 0, 2230, 2231, 5, 1140, 0, 0, 2231, + 2233, 3, 124, 62, 0, 2232, 2230, 1, 0, 0, 0, 2233, 2236, 1, 0, 0, 0, 2234, + 2232, 1, 0, 0, 0, 2234, 2235, 1, 0, 0, 0, 2235, 2237, 1, 0, 0, 0, 2236, + 2234, 1, 0, 0, 0, 2237, 2238, 5, 1139, 0, 0, 2238, 2240, 1, 0, 0, 0, 2239, + 2228, 1, 0, 0, 0, 2239, 2240, 1, 0, 0, 0, 2240, 2263, 1, 0, 0, 0, 2241, + 2242, 5, 129, 0, 0, 2242, 2246, 3, 584, 292, 0, 2243, 2245, 3, 126, 63, + 0, 2244, 2243, 1, 0, 0, 0, 2245, 2248, 1, 0, 0, 0, 2246, 2244, 1, 0, 0, + 0, 2246, 2247, 1, 0, 0, 0, 2247, 2260, 1, 0, 0, 0, 2248, 2246, 1, 0, 0, + 0, 2249, 2250, 5, 1138, 0, 0, 2250, 2255, 3, 124, 62, 0, 2251, 2252, 5, + 1140, 0, 0, 2252, 2254, 3, 124, 62, 0, 2253, 2251, 1, 0, 0, 0, 2254, 2257, + 1, 0, 0, 0, 2255, 2253, 1, 0, 0, 0, 2255, 2256, 1, 0, 0, 0, 2256, 2258, + 1, 0, 0, 0, 2257, 2255, 1, 0, 0, 0, 2258, 2259, 5, 1139, 0, 0, 2259, 2261, + 1, 0, 0, 0, 2260, 2249, 1, 0, 0, 0, 2260, 2261, 1, 0, 0, 0, 2261, 2263, + 1, 0, 0, 0, 2262, 2116, 1, 0, 0, 0, 2262, 2150, 1, 0, 0, 0, 2262, 2175, + 1, 0, 0, 0, 2262, 2208, 1, 0, 0, 0, 2262, 2241, 1, 0, 0, 0, 2263, 119, + 1, 0, 0, 0, 2264, 2268, 3, 602, 301, 0, 2265, 2268, 3, 688, 344, 0, 2266, + 2268, 5, 110, 0, 0, 2267, 2264, 1, 0, 0, 0, 2267, 2265, 1, 0, 0, 0, 2267, + 2266, 1, 0, 0, 0, 2268, 121, 1, 0, 0, 0, 2269, 2270, 5, 1138, 0, 0, 2270, + 2273, 3, 120, 60, 0, 2271, 2272, 5, 1140, 0, 0, 2272, 2274, 3, 120, 60, + 0, 2273, 2271, 1, 0, 0, 0, 2274, 2275, 1, 0, 0, 0, 2275, 2273, 1, 0, 0, + 0, 2275, 2276, 1, 0, 0, 0, 2276, 2277, 1, 0, 0, 0, 2277, 2278, 5, 1139, + 0, 0, 2278, 123, 1, 0, 0, 0, 2279, 2280, 5, 642, 0, 0, 2280, 2284, 3, 584, + 292, 0, 2281, 2283, 3, 126, 63, 0, 2282, 2281, 1, 0, 0, 0, 2283, 2286, + 1, 0, 0, 0, 2284, 2282, 1, 0, 0, 0, 2284, 2285, 1, 0, 0, 0, 2285, 125, + 1, 0, 0, 0, 2286, 2284, 1, 0, 0, 0, 2287, 2289, 5, 42, 0, 0, 2288, 2287, + 1, 0, 0, 0, 2288, 2289, 1, 0, 0, 0, 2289, 2291, 1, 0, 0, 0, 2290, 2292, + 5, 637, 0, 0, 2291, 2290, 1, 0, 0, 0, 2291, 2292, 1, 0, 0, 0, 2292, 2293, + 1, 0, 0, 0, 2293, 2295, 5, 410, 0, 0, 2294, 2296, 5, 1129, 0, 0, 2295, + 2294, 1, 0, 0, 0, 2295, 2296, 1, 0, 0, 0, 2296, 2297, 1, 0, 0, 0, 2297, + 2336, 3, 572, 286, 0, 2298, 2300, 5, 369, 0, 0, 2299, 2301, 5, 1129, 0, + 0, 2300, 2299, 1, 0, 0, 0, 2300, 2301, 1, 0, 0, 0, 2301, 2302, 1, 0, 0, + 0, 2302, 2336, 5, 1153, 0, 0, 2303, 2304, 5, 389, 0, 0, 2304, 2306, 5, + 396, 0, 0, 2305, 2307, 5, 1129, 0, 0, 2306, 2305, 1, 0, 0, 0, 2306, 2307, + 1, 0, 0, 0, 2307, 2308, 1, 0, 0, 0, 2308, 2336, 5, 1153, 0, 0, 2309, 2310, + 5, 81, 0, 0, 2310, 2312, 5, 396, 0, 0, 2311, 2313, 5, 1129, 0, 0, 2312, + 2311, 1, 0, 0, 0, 2312, 2313, 1, 0, 0, 0, 2313, 2314, 1, 0, 0, 0, 2314, + 2336, 5, 1153, 0, 0, 2315, 2317, 5, 501, 0, 0, 2316, 2318, 5, 1129, 0, + 0, 2317, 2316, 1, 0, 0, 0, 2317, 2318, 1, 0, 0, 0, 2318, 2319, 1, 0, 0, + 0, 2319, 2336, 3, 590, 295, 0, 2320, 2322, 5, 511, 0, 0, 2321, 2323, 5, + 1129, 0, 0, 2322, 2321, 1, 0, 0, 0, 2322, 2323, 1, 0, 0, 0, 2323, 2324, + 1, 0, 0, 0, 2324, 2336, 3, 590, 295, 0, 2325, 2327, 5, 648, 0, 0, 2326, + 2328, 5, 1129, 0, 0, 2327, 2326, 1, 0, 0, 0, 2327, 2328, 1, 0, 0, 0, 2328, + 2329, 1, 0, 0, 0, 2329, 2336, 3, 584, 292, 0, 2330, 2332, 5, 529, 0, 0, + 2331, 2333, 5, 1129, 0, 0, 2332, 2331, 1, 0, 0, 0, 2332, 2333, 1, 0, 0, + 0, 2333, 2334, 1, 0, 0, 0, 2334, 2336, 3, 584, 292, 0, 2335, 2288, 1, 0, + 0, 0, 2335, 2298, 1, 0, 0, 0, 2335, 2303, 1, 0, 0, 0, 2335, 2309, 1, 0, + 0, 0, 2335, 2315, 1, 0, 0, 0, 2335, 2320, 1, 0, 0, 0, 2335, 2325, 1, 0, + 0, 0, 2335, 2330, 1, 0, 0, 0, 2336, 127, 1, 0, 0, 0, 2337, 2338, 5, 7, + 0, 0, 2338, 2340, 7, 0, 0, 0, 2339, 2341, 3, 584, 292, 0, 2340, 2339, 1, + 0, 0, 0, 2340, 2341, 1, 0, 0, 0, 2341, 2343, 1, 0, 0, 0, 2342, 2344, 3, + 58, 29, 0, 2343, 2342, 1, 0, 0, 0, 2344, 2345, 1, 0, 0, 0, 2345, 2343, + 1, 0, 0, 0, 2345, 2346, 1, 0, 0, 0, 2346, 2356, 1, 0, 0, 0, 2347, 2348, + 5, 7, 0, 0, 2348, 2349, 7, 0, 0, 0, 2349, 2350, 3, 584, 292, 0, 2350, 2351, + 5, 665, 0, 0, 2351, 2352, 5, 389, 0, 0, 2352, 2353, 5, 396, 0, 0, 2353, + 2354, 5, 517, 0, 0, 2354, 2356, 1, 0, 0, 0, 2355, 2337, 1, 0, 0, 0, 2355, + 2347, 1, 0, 0, 0, 2356, 129, 1, 0, 0, 0, 2357, 2359, 5, 7, 0, 0, 2358, + 2360, 3, 64, 32, 0, 2359, 2358, 1, 0, 0, 0, 2359, 2360, 1, 0, 0, 0, 2360, + 2361, 1, 0, 0, 0, 2361, 2362, 5, 416, 0, 0, 2362, 2366, 3, 550, 275, 0, + 2363, 2364, 5, 118, 0, 0, 2364, 2365, 5, 606, 0, 0, 2365, 2367, 3, 66, + 33, 0, 2366, 2363, 1, 0, 0, 0, 2366, 2367, 1, 0, 0, 0, 2367, 2374, 1, 0, + 0, 0, 2368, 2369, 5, 118, 0, 0, 2369, 2371, 5, 372, 0, 0, 2370, 2372, 5, + 114, 0, 0, 2371, 2370, 1, 0, 0, 0, 2371, 2372, 1, 0, 0, 0, 2372, 2373, + 1, 0, 0, 0, 2373, 2375, 5, 562, 0, 0, 2374, 2368, 1, 0, 0, 0, 2374, 2375, + 1, 0, 0, 0, 2375, 2379, 1, 0, 0, 0, 2376, 2377, 5, 139, 0, 0, 2377, 2378, + 5, 175, 0, 0, 2378, 2380, 3, 550, 275, 0, 2379, 2376, 1, 0, 0, 0, 2379, + 2380, 1, 0, 0, 0, 2380, 2382, 1, 0, 0, 0, 2381, 2383, 3, 74, 37, 0, 2382, + 2381, 1, 0, 0, 0, 2382, 2383, 1, 0, 0, 0, 2383, 2386, 1, 0, 0, 0, 2384, + 2385, 5, 369, 0, 0, 2385, 2387, 5, 1153, 0, 0, 2386, 2384, 1, 0, 0, 0, + 2386, 2387, 1, 0, 0, 0, 2387, 2390, 1, 0, 0, 0, 2388, 2389, 5, 400, 0, + 0, 2389, 2391, 3, 388, 194, 0, 2390, 2388, 1, 0, 0, 0, 2390, 2391, 1, 0, + 0, 0, 2391, 131, 1, 0, 0, 0, 2392, 2393, 5, 7, 0, 0, 2393, 2394, 5, 438, + 0, 0, 2394, 2398, 3, 550, 275, 0, 2395, 2397, 3, 84, 42, 0, 2396, 2395, + 1, 0, 0, 0, 2397, 2400, 1, 0, 0, 0, 2398, 2396, 1, 0, 0, 0, 2398, 2399, + 1, 0, 0, 0, 2399, 133, 1, 0, 0, 0, 2400, 2398, 1, 0, 0, 0, 2401, 2402, + 5, 7, 0, 0, 2402, 2403, 5, 458, 0, 0, 2403, 2404, 5, 600, 0, 0, 2404, 2405, + 5, 792, 0, 0, 2405, 2406, 5, 478, 0, 0, 2406, 2407, 5, 91, 0, 0, 2407, + 135, 1, 0, 0, 0, 2408, 2409, 5, 7, 0, 0, 2409, 2410, 5, 476, 0, 0, 2410, + 2411, 5, 73, 0, 0, 2411, 2412, 3, 584, 292, 0, 2412, 2413, 5, 5, 0, 0, + 2413, 2414, 5, 660, 0, 0, 2414, 2420, 5, 1153, 0, 0, 2415, 2417, 5, 454, + 0, 0, 2416, 2418, 5, 1129, 0, 0, 2417, 2416, 1, 0, 0, 0, 2417, 2418, 1, + 0, 0, 0, 2418, 2419, 1, 0, 0, 0, 2419, 2421, 3, 592, 296, 0, 2420, 2415, + 1, 0, 0, 0, 2420, 2421, 1, 0, 0, 0, 2421, 2423, 1, 0, 0, 0, 2422, 2424, + 5, 675, 0, 0, 2423, 2422, 1, 0, 0, 0, 2423, 2424, 1, 0, 0, 0, 2424, 2425, + 1, 0, 0, 0, 2425, 2427, 5, 410, 0, 0, 2426, 2428, 5, 1129, 0, 0, 2427, + 2426, 1, 0, 0, 0, 2427, 2428, 1, 0, 0, 0, 2428, 2429, 1, 0, 0, 0, 2429, + 2430, 3, 572, 286, 0, 2430, 137, 1, 0, 0, 0, 2431, 2432, 5, 7, 0, 0, 2432, + 2433, 5, 131, 0, 0, 2433, 2437, 3, 550, 275, 0, 2434, 2436, 3, 84, 42, + 0, 2435, 2434, 1, 0, 0, 0, 2436, 2439, 1, 0, 0, 0, 2437, 2435, 1, 0, 0, + 0, 2437, 2438, 1, 0, 0, 0, 2438, 139, 1, 0, 0, 0, 2439, 2437, 1, 0, 0, + 0, 2440, 2441, 5, 7, 0, 0, 2441, 2442, 5, 609, 0, 0, 2442, 2443, 3, 584, + 292, 0, 2443, 2444, 5, 542, 0, 0, 2444, 2445, 5, 1138, 0, 0, 2445, 2450, + 3, 86, 43, 0, 2446, 2447, 5, 1140, 0, 0, 2447, 2449, 3, 86, 43, 0, 2448, + 2446, 1, 0, 0, 0, 2449, 2452, 1, 0, 0, 0, 2450, 2448, 1, 0, 0, 0, 2450, + 2451, 1, 0, 0, 0, 2451, 2453, 1, 0, 0, 0, 2452, 2450, 1, 0, 0, 0, 2453, + 2454, 5, 1139, 0, 0, 2454, 141, 1, 0, 0, 0, 2455, 2457, 5, 7, 0, 0, 2456, + 2458, 7, 1, 0, 0, 2457, 2456, 1, 0, 0, 0, 2457, 2458, 1, 0, 0, 0, 2458, + 2460, 1, 0, 0, 0, 2459, 2461, 5, 78, 0, 0, 2460, 2459, 1, 0, 0, 0, 2460, + 2461, 1, 0, 0, 0, 2461, 2462, 1, 0, 0, 0, 2462, 2463, 5, 172, 0, 0, 2463, + 2465, 3, 552, 276, 0, 2464, 2466, 3, 646, 323, 0, 2465, 2464, 1, 0, 0, + 0, 2465, 2466, 1, 0, 0, 0, 2466, 2475, 1, 0, 0, 0, 2467, 2472, 3, 148, + 74, 0, 2468, 2469, 5, 1140, 0, 0, 2469, 2471, 3, 148, 74, 0, 2470, 2468, + 1, 0, 0, 0, 2471, 2474, 1, 0, 0, 0, 2472, 2470, 1, 0, 0, 0, 2472, 2473, + 1, 0, 0, 0, 2473, 2476, 1, 0, 0, 0, 2474, 2472, 1, 0, 0, 0, 2475, 2467, + 1, 0, 0, 0, 2475, 2476, 1, 0, 0, 0, 2476, 2478, 1, 0, 0, 0, 2477, 2479, + 3, 112, 56, 0, 2478, 2477, 1, 0, 0, 0, 2478, 2479, 1, 0, 0, 0, 2479, 143, + 1, 0, 0, 0, 2480, 2481, 5, 7, 0, 0, 2481, 2482, 5, 648, 0, 0, 2482, 2483, + 3, 584, 292, 0, 2483, 2484, 7, 33, 0, 0, 2484, 2485, 5, 390, 0, 0, 2485, + 2489, 5, 1153, 0, 0, 2486, 2487, 5, 454, 0, 0, 2487, 2488, 5, 1129, 0, + 0, 2488, 2490, 3, 592, 296, 0, 2489, 2486, 1, 0, 0, 0, 2489, 2490, 1, 0, + 0, 0, 2490, 2492, 1, 0, 0, 0, 2491, 2493, 5, 675, 0, 0, 2492, 2491, 1, + 0, 0, 0, 2492, 2493, 1, 0, 0, 0, 2493, 2494, 1, 0, 0, 0, 2494, 2496, 5, + 410, 0, 0, 2495, 2497, 5, 1129, 0, 0, 2496, 2495, 1, 0, 0, 0, 2496, 2497, + 1, 0, 0, 0, 2497, 2498, 1, 0, 0, 0, 2498, 2499, 3, 572, 286, 0, 2499, 145, + 1, 0, 0, 0, 2500, 2504, 5, 7, 0, 0, 2501, 2502, 5, 337, 0, 0, 2502, 2503, + 5, 1129, 0, 0, 2503, 2505, 7, 10, 0, 0, 2504, 2501, 1, 0, 0, 0, 2504, 2505, + 1, 0, 0, 0, 2505, 2507, 1, 0, 0, 0, 2506, 2508, 3, 64, 32, 0, 2507, 2506, + 1, 0, 0, 0, 2507, 2508, 1, 0, 0, 0, 2508, 2512, 1, 0, 0, 0, 2509, 2510, + 5, 160, 0, 0, 2510, 2511, 5, 607, 0, 0, 2511, 2513, 7, 11, 0, 0, 2512, + 2509, 1, 0, 0, 0, 2512, 2513, 1, 0, 0, 0, 2513, 2514, 1, 0, 0, 0, 2514, + 2515, 5, 672, 0, 0, 2515, 2520, 3, 550, 275, 0, 2516, 2517, 5, 1138, 0, + 0, 2517, 2518, 3, 616, 308, 0, 2518, 2519, 5, 1139, 0, 0, 2519, 2521, 1, + 0, 0, 0, 2520, 2516, 1, 0, 0, 0, 2520, 2521, 1, 0, 0, 0, 2521, 2522, 1, + 0, 0, 0, 2522, 2523, 5, 12, 0, 0, 2523, 2530, 3, 200, 100, 0, 2524, 2526, + 5, 192, 0, 0, 2525, 2527, 7, 12, 0, 0, 2526, 2525, 1, 0, 0, 0, 2526, 2527, + 1, 0, 0, 0, 2527, 2528, 1, 0, 0, 0, 2528, 2529, 5, 26, 0, 0, 2529, 2531, + 5, 120, 0, 0, 2530, 2524, 1, 0, 0, 0, 2530, 2531, 1, 0, 0, 0, 2531, 147, + 1, 0, 0, 0, 2532, 2539, 3, 106, 53, 0, 2533, 2535, 5, 1140, 0, 0, 2534, + 2533, 1, 0, 0, 0, 2534, 2535, 1, 0, 0, 0, 2535, 2536, 1, 0, 0, 0, 2536, + 2538, 3, 106, 53, 0, 2537, 2534, 1, 0, 0, 0, 2538, 2541, 1, 0, 0, 0, 2539, + 2537, 1, 0, 0, 0, 2539, 2540, 1, 0, 0, 0, 2540, 2884, 1, 0, 0, 0, 2541, + 2539, 1, 0, 0, 0, 2542, 2544, 5, 5, 0, 0, 2543, 2545, 5, 28, 0, 0, 2544, + 2543, 1, 0, 0, 0, 2544, 2545, 1, 0, 0, 0, 2545, 2546, 1, 0, 0, 0, 2546, + 2547, 3, 584, 292, 0, 2547, 2551, 3, 92, 46, 0, 2548, 2552, 5, 431, 0, + 0, 2549, 2550, 5, 335, 0, 0, 2550, 2552, 3, 584, 292, 0, 2551, 2548, 1, + 0, 0, 0, 2551, 2549, 1, 0, 0, 0, 2551, 2552, 1, 0, 0, 0, 2552, 2884, 1, + 0, 0, 0, 2553, 2555, 5, 5, 0, 0, 2554, 2556, 5, 28, 0, 0, 2555, 2554, 1, + 0, 0, 0, 2555, 2556, 1, 0, 0, 0, 2556, 2557, 1, 0, 0, 0, 2557, 2558, 5, + 1138, 0, 0, 2558, 2559, 3, 584, 292, 0, 2559, 2566, 3, 92, 46, 0, 2560, + 2561, 5, 1140, 0, 0, 2561, 2562, 3, 584, 292, 0, 2562, 2563, 3, 92, 46, + 0, 2563, 2565, 1, 0, 0, 0, 2564, 2560, 1, 0, 0, 0, 2565, 2568, 1, 0, 0, + 0, 2566, 2564, 1, 0, 0, 0, 2566, 2567, 1, 0, 0, 0, 2567, 2569, 1, 0, 0, + 0, 2568, 2566, 1, 0, 0, 0, 2569, 2570, 5, 1139, 0, 0, 2570, 2884, 1, 0, + 0, 0, 2571, 2572, 5, 5, 0, 0, 2572, 2574, 7, 20, 0, 0, 2573, 2575, 3, 584, + 292, 0, 2574, 2573, 1, 0, 0, 0, 2574, 2575, 1, 0, 0, 0, 2575, 2577, 1, + 0, 0, 0, 2576, 2578, 3, 76, 38, 0, 2577, 2576, 1, 0, 0, 0, 2577, 2578, + 1, 0, 0, 0, 2578, 2579, 1, 0, 0, 0, 2579, 2583, 3, 622, 311, 0, 2580, 2582, + 3, 78, 39, 0, 2581, 2580, 1, 0, 0, 0, 2582, 2585, 1, 0, 0, 0, 2583, 2581, + 1, 0, 0, 0, 2583, 2584, 1, 0, 0, 0, 2584, 2884, 1, 0, 0, 0, 2585, 2583, + 1, 0, 0, 0, 2586, 2591, 5, 5, 0, 0, 2587, 2589, 5, 30, 0, 0, 2588, 2590, + 3, 584, 292, 0, 2589, 2588, 1, 0, 0, 0, 2589, 2590, 1, 0, 0, 0, 2590, 2592, + 1, 0, 0, 0, 2591, 2587, 1, 0, 0, 0, 2591, 2592, 1, 0, 0, 0, 2592, 2593, + 1, 0, 0, 0, 2593, 2594, 5, 130, 0, 0, 2594, 2596, 5, 91, 0, 0, 2595, 2597, + 3, 584, 292, 0, 2596, 2595, 1, 0, 0, 0, 2596, 2597, 1, 0, 0, 0, 2597, 2599, + 1, 0, 0, 0, 2598, 2600, 3, 76, 38, 0, 2599, 2598, 1, 0, 0, 0, 2599, 2600, + 1, 0, 0, 0, 2600, 2601, 1, 0, 0, 0, 2601, 2605, 3, 622, 311, 0, 2602, 2604, + 3, 78, 39, 0, 2603, 2602, 1, 0, 0, 0, 2604, 2607, 1, 0, 0, 0, 2605, 2603, + 1, 0, 0, 0, 2605, 2606, 1, 0, 0, 0, 2606, 2884, 1, 0, 0, 0, 2607, 2605, + 1, 0, 0, 0, 2608, 2613, 5, 5, 0, 0, 2609, 2611, 5, 30, 0, 0, 2610, 2612, + 3, 584, 292, 0, 2611, 2610, 1, 0, 0, 0, 2611, 2612, 1, 0, 0, 0, 2612, 2614, + 1, 0, 0, 0, 2613, 2609, 1, 0, 0, 0, 2613, 2614, 1, 0, 0, 0, 2614, 2615, + 1, 0, 0, 0, 2615, 2617, 5, 181, 0, 0, 2616, 2618, 7, 20, 0, 0, 2617, 2616, + 1, 0, 0, 0, 2617, 2618, 1, 0, 0, 0, 2618, 2620, 1, 0, 0, 0, 2619, 2621, + 3, 584, 292, 0, 2620, 2619, 1, 0, 0, 0, 2620, 2621, 1, 0, 0, 0, 2621, 2623, + 1, 0, 0, 0, 2622, 2624, 3, 76, 38, 0, 2623, 2622, 1, 0, 0, 0, 2623, 2624, + 1, 0, 0, 0, 2624, 2625, 1, 0, 0, 0, 2625, 2629, 3, 622, 311, 0, 2626, 2628, + 3, 78, 39, 0, 2627, 2626, 1, 0, 0, 0, 2628, 2631, 1, 0, 0, 0, 2629, 2627, + 1, 0, 0, 0, 2629, 2630, 1, 0, 0, 0, 2630, 2884, 1, 0, 0, 0, 2631, 2629, + 1, 0, 0, 0, 2632, 2633, 5, 5, 0, 0, 2633, 2635, 7, 22, 0, 0, 2634, 2636, + 7, 20, 0, 0, 2635, 2634, 1, 0, 0, 0, 2635, 2636, 1, 0, 0, 0, 2636, 2638, + 1, 0, 0, 0, 2637, 2639, 3, 584, 292, 0, 2638, 2637, 1, 0, 0, 0, 2638, 2639, + 1, 0, 0, 0, 2639, 2640, 1, 0, 0, 0, 2640, 2644, 3, 622, 311, 0, 2641, 2643, + 3, 78, 39, 0, 2642, 2641, 1, 0, 0, 0, 2643, 2646, 1, 0, 0, 0, 2644, 2642, + 1, 0, 0, 0, 2644, 2645, 1, 0, 0, 0, 2645, 2884, 1, 0, 0, 0, 2646, 2644, + 1, 0, 0, 0, 2647, 2652, 5, 5, 0, 0, 2648, 2650, 5, 30, 0, 0, 2649, 2651, + 3, 584, 292, 0, 2650, 2649, 1, 0, 0, 0, 2650, 2651, 1, 0, 0, 0, 2651, 2653, + 1, 0, 0, 0, 2652, 2648, 1, 0, 0, 0, 2652, 2653, 1, 0, 0, 0, 2653, 2654, + 1, 0, 0, 0, 2654, 2655, 5, 67, 0, 0, 2655, 2657, 5, 91, 0, 0, 2656, 2658, + 3, 584, 292, 0, 2657, 2656, 1, 0, 0, 0, 2657, 2658, 1, 0, 0, 0, 2658, 2659, + 1, 0, 0, 0, 2659, 2660, 3, 622, 311, 0, 2660, 2661, 3, 98, 49, 0, 2661, + 2884, 1, 0, 0, 0, 2662, 2667, 5, 5, 0, 0, 2663, 2665, 5, 30, 0, 0, 2664, + 2666, 3, 584, 292, 0, 2665, 2664, 1, 0, 0, 0, 2665, 2666, 1, 0, 0, 0, 2666, + 2668, 1, 0, 0, 0, 2667, 2663, 1, 0, 0, 0, 2667, 2668, 1, 0, 0, 0, 2668, + 2669, 1, 0, 0, 0, 2669, 2676, 5, 26, 0, 0, 2670, 2677, 3, 584, 292, 0, + 2671, 2677, 3, 594, 297, 0, 2672, 2673, 5, 1138, 0, 0, 2673, 2674, 3, 688, + 344, 0, 2674, 2675, 5, 1139, 0, 0, 2675, 2677, 1, 0, 0, 0, 2676, 2670, + 1, 0, 0, 0, 2676, 2671, 1, 0, 0, 0, 2676, 2672, 1, 0, 0, 0, 2677, 2679, + 1, 0, 0, 0, 2678, 2680, 5, 114, 0, 0, 2679, 2678, 1, 0, 0, 0, 2679, 2680, + 1, 0, 0, 0, 2680, 2682, 1, 0, 0, 0, 2681, 2683, 5, 57, 0, 0, 2682, 2681, + 1, 0, 0, 0, 2682, 2683, 1, 0, 0, 0, 2683, 2884, 1, 0, 0, 0, 2684, 2689, + 5, 7, 0, 0, 2685, 2687, 5, 30, 0, 0, 2686, 2688, 3, 584, 292, 0, 2687, + 2686, 1, 0, 0, 0, 2687, 2688, 1, 0, 0, 0, 2688, 2690, 1, 0, 0, 0, 2689, + 2685, 1, 0, 0, 0, 2689, 2690, 1, 0, 0, 0, 2690, 2691, 1, 0, 0, 0, 2691, + 2698, 5, 26, 0, 0, 2692, 2699, 3, 584, 292, 0, 2693, 2699, 3, 594, 297, + 0, 2694, 2695, 5, 1138, 0, 0, 2695, 2696, 3, 688, 344, 0, 2696, 2697, 5, + 1139, 0, 0, 2697, 2699, 1, 0, 0, 0, 2698, 2692, 1, 0, 0, 0, 2698, 2693, + 1, 0, 0, 0, 2698, 2694, 1, 0, 0, 0, 2699, 2701, 1, 0, 0, 0, 2700, 2702, + 5, 114, 0, 0, 2701, 2700, 1, 0, 0, 0, 2701, 2702, 1, 0, 0, 0, 2702, 2704, + 1, 0, 0, 0, 2703, 2705, 5, 57, 0, 0, 2704, 2703, 1, 0, 0, 0, 2704, 2705, + 1, 0, 0, 0, 2705, 2884, 1, 0, 0, 0, 2706, 2711, 5, 5, 0, 0, 2707, 2709, + 5, 30, 0, 0, 2708, 2710, 3, 584, 292, 0, 2709, 2708, 1, 0, 0, 0, 2709, + 2710, 1, 0, 0, 0, 2710, 2712, 1, 0, 0, 0, 2711, 2707, 1, 0, 0, 0, 2711, + 2712, 1, 0, 0, 0, 2712, 2713, 1, 0, 0, 0, 2713, 2714, 5, 26, 0, 0, 2714, + 2715, 5, 1138, 0, 0, 2715, 2716, 3, 688, 344, 0, 2716, 2717, 5, 1139, 0, + 0, 2717, 2884, 1, 0, 0, 0, 2718, 2720, 5, 337, 0, 0, 2719, 2721, 5, 1129, + 0, 0, 2720, 2719, 1, 0, 0, 0, 2720, 2721, 1, 0, 0, 0, 2721, 2722, 1, 0, + 0, 0, 2722, 2884, 7, 34, 0, 0, 2723, 2725, 5, 7, 0, 0, 2724, 2726, 5, 28, + 0, 0, 2725, 2724, 1, 0, 0, 0, 2725, 2726, 1, 0, 0, 0, 2726, 2727, 1, 0, + 0, 0, 2727, 2733, 3, 584, 292, 0, 2728, 2729, 5, 153, 0, 0, 2729, 2730, + 5, 42, 0, 0, 2730, 2734, 3, 634, 317, 0, 2731, 2732, 5, 51, 0, 0, 2732, + 2734, 5, 42, 0, 0, 2733, 2728, 1, 0, 0, 0, 2733, 2731, 1, 0, 0, 0, 2734, + 2884, 1, 0, 0, 0, 2735, 2737, 5, 24, 0, 0, 2736, 2738, 5, 28, 0, 0, 2737, + 2736, 1, 0, 0, 0, 2737, 2738, 1, 0, 0, 0, 2738, 2739, 1, 0, 0, 0, 2739, + 2740, 3, 584, 292, 0, 2740, 2741, 3, 584, 292, 0, 2741, 2745, 3, 92, 46, + 0, 2742, 2746, 5, 431, 0, 0, 2743, 2744, 5, 335, 0, 0, 2744, 2746, 3, 584, + 292, 0, 2745, 2742, 1, 0, 0, 0, 2745, 2743, 1, 0, 0, 0, 2745, 2746, 1, + 0, 0, 0, 2746, 2884, 1, 0, 0, 0, 2747, 2748, 5, 139, 0, 0, 2748, 2749, + 5, 28, 0, 0, 2749, 2750, 3, 584, 292, 0, 2750, 2751, 5, 175, 0, 0, 2751, + 2752, 3, 584, 292, 0, 2752, 2884, 1, 0, 0, 0, 2753, 2755, 5, 103, 0, 0, + 2754, 2756, 5, 1129, 0, 0, 2755, 2754, 1, 0, 0, 0, 2755, 2756, 1, 0, 0, + 0, 2756, 2757, 1, 0, 0, 0, 2757, 2884, 7, 4, 0, 0, 2758, 2760, 5, 513, + 0, 0, 2759, 2761, 5, 28, 0, 0, 2760, 2759, 1, 0, 0, 0, 2760, 2761, 1, 0, + 0, 0, 2761, 2762, 1, 0, 0, 0, 2762, 2763, 3, 584, 292, 0, 2763, 2767, 3, + 92, 46, 0, 2764, 2768, 5, 431, 0, 0, 2765, 2766, 5, 335, 0, 0, 2766, 2768, + 3, 584, 292, 0, 2767, 2764, 1, 0, 0, 0, 2767, 2765, 1, 0, 0, 0, 2767, 2768, + 1, 0, 0, 0, 2768, 2884, 1, 0, 0, 0, 2769, 2771, 5, 51, 0, 0, 2770, 2772, + 5, 28, 0, 0, 2771, 2770, 1, 0, 0, 0, 2771, 2772, 1, 0, 0, 0, 2772, 2773, + 1, 0, 0, 0, 2773, 2775, 3, 584, 292, 0, 2774, 2776, 5, 144, 0, 0, 2775, + 2774, 1, 0, 0, 0, 2775, 2776, 1, 0, 0, 0, 2776, 2884, 1, 0, 0, 0, 2777, + 2778, 5, 51, 0, 0, 2778, 2779, 7, 35, 0, 0, 2779, 2884, 3, 584, 292, 0, + 2780, 2781, 5, 51, 0, 0, 2781, 2782, 5, 130, 0, 0, 2782, 2884, 5, 91, 0, + 0, 2783, 2784, 5, 51, 0, 0, 2784, 2785, 7, 20, 0, 0, 2785, 2884, 3, 584, + 292, 0, 2786, 2787, 5, 139, 0, 0, 2787, 2788, 7, 20, 0, 0, 2788, 2789, + 3, 584, 292, 0, 2789, 2790, 5, 175, 0, 0, 2790, 2791, 3, 584, 292, 0, 2791, + 2884, 1, 0, 0, 0, 2792, 2794, 5, 7, 0, 0, 2793, 2795, 5, 28, 0, 0, 2794, + 2793, 1, 0, 0, 0, 2794, 2795, 1, 0, 0, 0, 2795, 2796, 1, 0, 0, 0, 2796, + 2810, 3, 584, 292, 0, 2797, 2798, 5, 153, 0, 0, 2798, 2804, 5, 42, 0, 0, + 2799, 2805, 3, 594, 297, 0, 2800, 2801, 5, 1138, 0, 0, 2801, 2802, 3, 688, + 344, 0, 2802, 2803, 5, 1139, 0, 0, 2803, 2805, 1, 0, 0, 0, 2804, 2799, + 1, 0, 0, 0, 2804, 2800, 1, 0, 0, 0, 2805, 2811, 1, 0, 0, 0, 2806, 2807, + 5, 153, 0, 0, 2807, 2811, 7, 15, 0, 0, 2808, 2809, 5, 51, 0, 0, 2809, 2811, + 5, 42, 0, 0, 2810, 2797, 1, 0, 0, 0, 2810, 2806, 1, 0, 0, 0, 2810, 2808, + 1, 0, 0, 0, 2811, 2884, 1, 0, 0, 0, 2812, 2813, 5, 7, 0, 0, 2813, 2814, + 5, 81, 0, 0, 2814, 2815, 3, 584, 292, 0, 2815, 2816, 7, 15, 0, 0, 2816, + 2884, 1, 0, 0, 0, 2817, 2818, 5, 51, 0, 0, 2818, 2819, 5, 67, 0, 0, 2819, + 2820, 5, 91, 0, 0, 2820, 2884, 3, 584, 292, 0, 2821, 2822, 5, 397, 0, 0, + 2822, 2884, 5, 92, 0, 0, 2823, 2824, 5, 404, 0, 0, 2824, 2884, 5, 92, 0, + 0, 2825, 2827, 5, 139, 0, 0, 2826, 2828, 7, 36, 0, 0, 2827, 2826, 1, 0, + 0, 0, 2827, 2828, 1, 0, 0, 0, 2828, 2831, 1, 0, 0, 0, 2829, 2832, 3, 584, + 292, 0, 2830, 2832, 3, 550, 275, 0, 2831, 2829, 1, 0, 0, 0, 2831, 2830, + 1, 0, 0, 0, 2832, 2884, 1, 0, 0, 0, 2833, 2834, 5, 124, 0, 0, 2834, 2835, + 5, 19, 0, 0, 2835, 2884, 3, 616, 308, 0, 2836, 2837, 5, 32, 0, 0, 2837, + 2841, 5, 175, 0, 0, 2838, 2842, 5, 842, 0, 0, 2839, 2840, 5, 25, 0, 0, + 2840, 2842, 5, 153, 0, 0, 2841, 2838, 1, 0, 0, 0, 2841, 2839, 1, 0, 0, + 0, 2842, 2843, 1, 0, 0, 0, 2843, 2846, 3, 568, 284, 0, 2844, 2845, 5, 27, + 0, 0, 2845, 2847, 3, 570, 285, 0, 2846, 2844, 1, 0, 0, 0, 2846, 2847, 1, + 0, 0, 0, 2847, 2884, 1, 0, 0, 0, 2848, 2850, 5, 42, 0, 0, 2849, 2848, 1, + 0, 0, 0, 2849, 2850, 1, 0, 0, 0, 2850, 2851, 1, 0, 0, 0, 2851, 2852, 5, + 25, 0, 0, 2852, 2853, 5, 153, 0, 0, 2853, 2854, 5, 1129, 0, 0, 2854, 2858, + 3, 568, 284, 0, 2855, 2856, 5, 27, 0, 0, 2856, 2857, 5, 1129, 0, 0, 2857, + 2859, 3, 570, 285, 0, 2858, 2855, 1, 0, 0, 0, 2858, 2859, 1, 0, 0, 0, 2859, + 2884, 1, 0, 0, 0, 2860, 2861, 5, 398, 0, 0, 2861, 2884, 5, 648, 0, 0, 2862, + 2863, 5, 451, 0, 0, 2863, 2884, 5, 648, 0, 0, 2864, 2884, 5, 66, 0, 0, + 2865, 2866, 7, 37, 0, 0, 2866, 2884, 5, 669, 0, 0, 2867, 2869, 5, 5, 0, + 0, 2868, 2870, 5, 28, 0, 0, 2869, 2868, 1, 0, 0, 0, 2869, 2870, 1, 0, 0, + 0, 2870, 2871, 1, 0, 0, 0, 2871, 2872, 5, 1138, 0, 0, 2872, 2877, 3, 90, + 45, 0, 2873, 2874, 5, 1140, 0, 0, 2874, 2876, 3, 90, 45, 0, 2875, 2873, + 1, 0, 0, 0, 2876, 2879, 1, 0, 0, 0, 2877, 2875, 1, 0, 0, 0, 2877, 2878, + 1, 0, 0, 0, 2878, 2880, 1, 0, 0, 0, 2879, 2877, 1, 0, 0, 0, 2880, 2881, + 5, 1139, 0, 0, 2881, 2884, 1, 0, 0, 0, 2882, 2884, 3, 150, 75, 0, 2883, + 2532, 1, 0, 0, 0, 2883, 2542, 1, 0, 0, 0, 2883, 2553, 1, 0, 0, 0, 2883, + 2571, 1, 0, 0, 0, 2883, 2586, 1, 0, 0, 0, 2883, 2608, 1, 0, 0, 0, 2883, + 2632, 1, 0, 0, 0, 2883, 2647, 1, 0, 0, 0, 2883, 2662, 1, 0, 0, 0, 2883, + 2684, 1, 0, 0, 0, 2883, 2706, 1, 0, 0, 0, 2883, 2718, 1, 0, 0, 0, 2883, + 2723, 1, 0, 0, 0, 2883, 2735, 1, 0, 0, 0, 2883, 2747, 1, 0, 0, 0, 2883, + 2753, 1, 0, 0, 0, 2883, 2758, 1, 0, 0, 0, 2883, 2769, 1, 0, 0, 0, 2883, + 2777, 1, 0, 0, 0, 2883, 2780, 1, 0, 0, 0, 2883, 2783, 1, 0, 0, 0, 2883, + 2786, 1, 0, 0, 0, 2883, 2792, 1, 0, 0, 0, 2883, 2812, 1, 0, 0, 0, 2883, + 2817, 1, 0, 0, 0, 2883, 2821, 1, 0, 0, 0, 2883, 2823, 1, 0, 0, 0, 2883, + 2825, 1, 0, 0, 0, 2883, 2833, 1, 0, 0, 0, 2883, 2836, 1, 0, 0, 0, 2883, + 2849, 1, 0, 0, 0, 2883, 2860, 1, 0, 0, 0, 2883, 2862, 1, 0, 0, 0, 2883, + 2864, 1, 0, 0, 0, 2883, 2865, 1, 0, 0, 0, 2883, 2867, 1, 0, 0, 0, 2883, + 2882, 1, 0, 0, 0, 2884, 149, 1, 0, 0, 0, 2885, 2886, 5, 5, 0, 0, 2886, + 2887, 5, 129, 0, 0, 2887, 2888, 5, 1138, 0, 0, 2888, 2893, 3, 118, 59, + 0, 2889, 2890, 5, 1140, 0, 0, 2890, 2892, 3, 118, 59, 0, 2891, 2889, 1, + 0, 0, 0, 2892, 2895, 1, 0, 0, 0, 2893, 2891, 1, 0, 0, 0, 2893, 2894, 1, + 0, 0, 0, 2894, 2896, 1, 0, 0, 0, 2895, 2893, 1, 0, 0, 0, 2896, 2897, 5, + 1139, 0, 0, 2897, 2984, 1, 0, 0, 0, 2898, 2899, 5, 51, 0, 0, 2899, 2900, + 5, 129, 0, 0, 2900, 2984, 3, 616, 308, 0, 2901, 2902, 5, 398, 0, 0, 2902, + 2905, 5, 129, 0, 0, 2903, 2906, 3, 616, 308, 0, 2904, 2906, 5, 6, 0, 0, + 2905, 2903, 1, 0, 0, 0, 2905, 2904, 1, 0, 0, 0, 2906, 2907, 1, 0, 0, 0, + 2907, 2984, 5, 648, 0, 0, 2908, 2909, 5, 451, 0, 0, 2909, 2912, 5, 129, + 0, 0, 2910, 2913, 3, 616, 308, 0, 2911, 2913, 5, 6, 0, 0, 2912, 2910, 1, + 0, 0, 0, 2912, 2911, 1, 0, 0, 0, 2913, 2914, 1, 0, 0, 0, 2914, 2984, 5, + 648, 0, 0, 2915, 2916, 5, 657, 0, 0, 2916, 2919, 5, 129, 0, 0, 2917, 2920, + 3, 616, 308, 0, 2918, 2920, 5, 6, 0, 0, 2919, 2917, 1, 0, 0, 0, 2919, 2918, + 1, 0, 0, 0, 2920, 2984, 1, 0, 0, 0, 2921, 2922, 5, 364, 0, 0, 2922, 2923, + 5, 129, 0, 0, 2923, 2984, 3, 590, 295, 0, 2924, 2925, 5, 580, 0, 0, 2925, + 2926, 5, 129, 0, 0, 2926, 2927, 3, 616, 308, 0, 2927, 2928, 5, 87, 0, 0, + 2928, 2929, 5, 1138, 0, 0, 2929, 2934, 3, 118, 59, 0, 2930, 2931, 5, 1140, + 0, 0, 2931, 2933, 3, 118, 59, 0, 2932, 2930, 1, 0, 0, 0, 2933, 2936, 1, + 0, 0, 0, 2934, 2932, 1, 0, 0, 0, 2934, 2935, 1, 0, 0, 0, 2935, 2937, 1, + 0, 0, 0, 2936, 2934, 1, 0, 0, 0, 2937, 2938, 5, 1139, 0, 0, 2938, 2984, + 1, 0, 0, 0, 2939, 2940, 5, 419, 0, 0, 2940, 2941, 5, 129, 0, 0, 2941, 2942, + 3, 584, 292, 0, 2942, 2943, 5, 192, 0, 0, 2943, 2944, 5, 172, 0, 0, 2944, + 2947, 3, 552, 276, 0, 2945, 2946, 7, 37, 0, 0, 2946, 2948, 5, 669, 0, 0, + 2947, 2945, 1, 0, 0, 0, 2947, 2948, 1, 0, 0, 0, 2948, 2984, 1, 0, 0, 0, + 2949, 2950, 5, 9, 0, 0, 2950, 2953, 5, 129, 0, 0, 2951, 2954, 3, 616, 308, + 0, 2952, 2954, 5, 6, 0, 0, 2953, 2951, 1, 0, 0, 0, 2953, 2952, 1, 0, 0, + 0, 2954, 2984, 1, 0, 0, 0, 2955, 2956, 5, 26, 0, 0, 2956, 2959, 5, 129, + 0, 0, 2957, 2960, 3, 616, 308, 0, 2958, 2960, 5, 6, 0, 0, 2959, 2957, 1, + 0, 0, 0, 2959, 2958, 1, 0, 0, 0, 2960, 2984, 1, 0, 0, 0, 2961, 2962, 5, + 119, 0, 0, 2962, 2965, 5, 129, 0, 0, 2963, 2966, 3, 616, 308, 0, 2964, + 2966, 5, 6, 0, 0, 2965, 2963, 1, 0, 0, 0, 2965, 2964, 1, 0, 0, 0, 2966, + 2984, 1, 0, 0, 0, 2967, 2968, 5, 570, 0, 0, 2968, 2971, 5, 129, 0, 0, 2969, + 2972, 3, 616, 308, 0, 2970, 2972, 5, 6, 0, 0, 2971, 2969, 1, 0, 0, 0, 2971, + 2970, 1, 0, 0, 0, 2972, 2984, 1, 0, 0, 0, 2973, 2974, 5, 581, 0, 0, 2974, + 2977, 5, 129, 0, 0, 2975, 2978, 3, 616, 308, 0, 2976, 2978, 5, 6, 0, 0, + 2977, 2975, 1, 0, 0, 0, 2977, 2976, 1, 0, 0, 0, 2978, 2984, 1, 0, 0, 0, + 2979, 2980, 5, 579, 0, 0, 2980, 2984, 5, 550, 0, 0, 2981, 2982, 5, 665, + 0, 0, 2982, 2984, 5, 550, 0, 0, 2983, 2885, 1, 0, 0, 0, 2983, 2898, 1, + 0, 0, 0, 2983, 2901, 1, 0, 0, 0, 2983, 2908, 1, 0, 0, 0, 2983, 2915, 1, + 0, 0, 0, 2983, 2921, 1, 0, 0, 0, 2983, 2924, 1, 0, 0, 0, 2983, 2939, 1, + 0, 0, 0, 2983, 2949, 1, 0, 0, 0, 2983, 2955, 1, 0, 0, 0, 2983, 2961, 1, + 0, 0, 0, 2983, 2967, 1, 0, 0, 0, 2983, 2973, 1, 0, 0, 0, 2983, 2979, 1, + 0, 0, 0, 2983, 2981, 1, 0, 0, 0, 2984, 151, 1, 0, 0, 0, 2985, 2986, 5, + 51, 0, 0, 2986, 2988, 7, 0, 0, 0, 2987, 2989, 3, 640, 320, 0, 2988, 2987, + 1, 0, 0, 0, 2988, 2989, 1, 0, 0, 0, 2989, 2990, 1, 0, 0, 0, 2990, 2991, + 3, 584, 292, 0, 2991, 153, 1, 0, 0, 0, 2992, 2993, 5, 51, 0, 0, 2993, 2995, + 5, 416, 0, 0, 2994, 2996, 3, 640, 320, 0, 2995, 2994, 1, 0, 0, 0, 2995, + 2996, 1, 0, 0, 0, 2996, 2997, 1, 0, 0, 0, 2997, 2998, 3, 550, 275, 0, 2998, + 155, 1, 0, 0, 0, 2999, 3000, 5, 51, 0, 0, 3000, 3002, 5, 81, 0, 0, 3001, + 3003, 7, 1, 0, 0, 3002, 3001, 1, 0, 0, 0, 3002, 3003, 1, 0, 0, 0, 3003, + 3004, 1, 0, 0, 0, 3004, 3005, 3, 584, 292, 0, 3005, 3006, 5, 118, 0, 0, + 3006, 3019, 3, 552, 276, 0, 3007, 3009, 5, 337, 0, 0, 3008, 3010, 5, 1129, + 0, 0, 3009, 3008, 1, 0, 0, 0, 3009, 3010, 1, 0, 0, 0, 3010, 3011, 1, 0, + 0, 0, 3011, 3018, 7, 3, 0, 0, 3012, 3014, 5, 103, 0, 0, 3013, 3015, 5, + 1129, 0, 0, 3014, 3013, 1, 0, 0, 0, 3014, 3015, 1, 0, 0, 0, 3015, 3016, + 1, 0, 0, 0, 3016, 3018, 7, 4, 0, 0, 3017, 3007, 1, 0, 0, 0, 3017, 3012, + 1, 0, 0, 0, 3018, 3021, 1, 0, 0, 0, 3019, 3017, 1, 0, 0, 0, 3019, 3020, + 1, 0, 0, 0, 3020, 157, 1, 0, 0, 0, 3021, 3019, 1, 0, 0, 0, 3022, 3023, + 5, 51, 0, 0, 3023, 3024, 5, 476, 0, 0, 3024, 3025, 5, 73, 0, 0, 3025, 3026, + 3, 584, 292, 0, 3026, 3027, 5, 410, 0, 0, 3027, 3028, 5, 1129, 0, 0, 3028, + 3029, 3, 572, 286, 0, 3029, 159, 1, 0, 0, 0, 3030, 3031, 5, 51, 0, 0, 3031, + 3033, 5, 131, 0, 0, 3032, 3034, 3, 640, 320, 0, 3033, 3032, 1, 0, 0, 0, + 3033, 3034, 1, 0, 0, 0, 3034, 3035, 1, 0, 0, 0, 3035, 3036, 3, 550, 275, + 0, 3036, 161, 1, 0, 0, 0, 3037, 3038, 5, 51, 0, 0, 3038, 3040, 5, 438, + 0, 0, 3039, 3041, 3, 640, 320, 0, 3040, 3039, 1, 0, 0, 0, 3040, 3041, 1, + 0, 0, 0, 3041, 3042, 1, 0, 0, 0, 3042, 3043, 3, 550, 275, 0, 3043, 163, + 1, 0, 0, 0, 3044, 3045, 5, 51, 0, 0, 3045, 3047, 5, 609, 0, 0, 3046, 3048, + 3, 640, 320, 0, 3047, 3046, 1, 0, 0, 0, 3047, 3048, 1, 0, 0, 0, 3048, 3049, + 1, 0, 0, 0, 3049, 3050, 3, 584, 292, 0, 3050, 165, 1, 0, 0, 0, 3051, 3053, + 5, 51, 0, 0, 3052, 3054, 5, 650, 0, 0, 3053, 3052, 1, 0, 0, 0, 3053, 3054, + 1, 0, 0, 0, 3054, 3055, 1, 0, 0, 0, 3055, 3057, 5, 172, 0, 0, 3056, 3058, + 3, 640, 320, 0, 3057, 3056, 1, 0, 0, 0, 3057, 3058, 1, 0, 0, 0, 3058, 3059, + 1, 0, 0, 0, 3059, 3061, 3, 620, 310, 0, 3060, 3062, 7, 38, 0, 0, 3061, + 3060, 1, 0, 0, 0, 3061, 3062, 1, 0, 0, 0, 3062, 167, 1, 0, 0, 0, 3063, + 3064, 5, 51, 0, 0, 3064, 3065, 5, 648, 0, 0, 3065, 3071, 3, 584, 292, 0, + 3066, 3068, 5, 410, 0, 0, 3067, 3069, 5, 1129, 0, 0, 3068, 3067, 1, 0, + 0, 0, 3068, 3069, 1, 0, 0, 0, 3069, 3070, 1, 0, 0, 0, 3070, 3072, 3, 572, + 286, 0, 3071, 3066, 1, 0, 0, 0, 3071, 3072, 1, 0, 0, 0, 3072, 169, 1, 0, + 0, 0, 3073, 3074, 5, 51, 0, 0, 3074, 3076, 5, 177, 0, 0, 3075, 3077, 3, + 640, 320, 0, 3076, 3075, 1, 0, 0, 0, 3076, 3077, 1, 0, 0, 0, 3077, 3078, + 1, 0, 0, 0, 3078, 3079, 3, 550, 275, 0, 3079, 171, 1, 0, 0, 0, 3080, 3081, + 5, 51, 0, 0, 3081, 3083, 5, 672, 0, 0, 3082, 3084, 3, 640, 320, 0, 3083, + 3082, 1, 0, 0, 0, 3083, 3084, 1, 0, 0, 0, 3084, 3085, 1, 0, 0, 0, 3085, + 3090, 3, 550, 275, 0, 3086, 3087, 5, 1140, 0, 0, 3087, 3089, 3, 550, 275, + 0, 3088, 3086, 1, 0, 0, 0, 3089, 3092, 1, 0, 0, 0, 3090, 3088, 1, 0, 0, + 0, 3090, 3091, 1, 0, 0, 0, 3091, 3094, 1, 0, 0, 0, 3092, 3090, 1, 0, 0, + 0, 3093, 3095, 7, 38, 0, 0, 3094, 3093, 1, 0, 0, 0, 3094, 3095, 1, 0, 0, + 0, 3095, 173, 1, 0, 0, 0, 3096, 3097, 5, 51, 0, 0, 3097, 3099, 5, 597, + 0, 0, 3098, 3100, 3, 640, 320, 0, 3099, 3098, 1, 0, 0, 0, 3099, 3100, 1, + 0, 0, 0, 3100, 3101, 1, 0, 0, 0, 3101, 3106, 3, 554, 277, 0, 3102, 3103, + 5, 1140, 0, 0, 3103, 3105, 3, 554, 277, 0, 3104, 3102, 1, 0, 0, 0, 3105, + 3108, 1, 0, 0, 0, 3106, 3104, 1, 0, 0, 0, 3106, 3107, 1, 0, 0, 0, 3107, + 175, 1, 0, 0, 0, 3108, 3106, 1, 0, 0, 0, 3109, 3110, 5, 153, 0, 0, 3110, + 3111, 5, 42, 0, 0, 3111, 3122, 5, 597, 0, 0, 3112, 3123, 5, 530, 0, 0, + 3113, 3123, 5, 6, 0, 0, 3114, 3119, 3, 554, 277, 0, 3115, 3116, 5, 1140, + 0, 0, 3116, 3118, 3, 554, 277, 0, 3117, 3115, 1, 0, 0, 0, 3118, 3121, 1, + 0, 0, 0, 3119, 3117, 1, 0, 0, 0, 3119, 3120, 1, 0, 0, 0, 3120, 3123, 1, + 0, 0, 0, 3121, 3119, 1, 0, 0, 0, 3122, 3112, 1, 0, 0, 0, 3122, 3113, 1, + 0, 0, 0, 3122, 3114, 1, 0, 0, 0, 3123, 3124, 1, 0, 0, 0, 3124, 3127, 5, + 175, 0, 0, 3125, 3128, 3, 564, 282, 0, 3126, 3128, 3, 584, 292, 0, 3127, + 3125, 1, 0, 0, 0, 3127, 3126, 1, 0, 0, 0, 3128, 3136, 1, 0, 0, 0, 3129, + 3132, 5, 1140, 0, 0, 3130, 3133, 3, 564, 282, 0, 3131, 3133, 3, 584, 292, + 0, 3132, 3130, 1, 0, 0, 0, 3132, 3131, 1, 0, 0, 0, 3133, 3135, 1, 0, 0, + 0, 3134, 3129, 1, 0, 0, 0, 3135, 3138, 1, 0, 0, 0, 3136, 3134, 1, 0, 0, + 0, 3136, 3137, 1, 0, 0, 0, 3137, 3143, 1, 0, 0, 0, 3138, 3136, 1, 0, 0, + 0, 3139, 3140, 5, 153, 0, 0, 3140, 3141, 5, 597, 0, 0, 3141, 3143, 3, 434, + 217, 0, 3142, 3109, 1, 0, 0, 0, 3142, 3139, 1, 0, 0, 0, 3143, 177, 1, 0, + 0, 0, 3144, 3145, 5, 139, 0, 0, 3145, 3146, 5, 172, 0, 0, 3146, 3151, 3, + 180, 90, 0, 3147, 3148, 5, 1140, 0, 0, 3148, 3150, 3, 180, 90, 0, 3149, + 3147, 1, 0, 0, 0, 3150, 3153, 1, 0, 0, 0, 3151, 3149, 1, 0, 0, 0, 3151, + 3152, 1, 0, 0, 0, 3152, 179, 1, 0, 0, 0, 3153, 3151, 1, 0, 0, 0, 3154, + 3155, 3, 552, 276, 0, 3155, 3156, 5, 175, 0, 0, 3156, 3157, 3, 552, 276, + 0, 3157, 181, 1, 0, 0, 0, 3158, 3160, 5, 657, 0, 0, 3159, 3161, 5, 172, + 0, 0, 3160, 3159, 1, 0, 0, 0, 3160, 3161, 1, 0, 0, 0, 3161, 3162, 1, 0, + 0, 0, 3162, 3163, 3, 552, 276, 0, 3163, 183, 1, 0, 0, 0, 3164, 3165, 5, + 20, 0, 0, 3165, 3172, 3, 550, 275, 0, 3166, 3169, 5, 1138, 0, 0, 3167, + 3170, 3, 628, 314, 0, 3168, 3170, 3, 624, 312, 0, 3169, 3167, 1, 0, 0, + 0, 3169, 3168, 1, 0, 0, 0, 3169, 3170, 1, 0, 0, 0, 3170, 3171, 1, 0, 0, + 0, 3171, 3173, 5, 1139, 0, 0, 3172, 3166, 1, 0, 0, 0, 3172, 3173, 1, 0, + 0, 0, 3173, 185, 1, 0, 0, 0, 3174, 3177, 3, 214, 107, 0, 3175, 3177, 3, + 216, 108, 0, 3176, 3174, 1, 0, 0, 0, 3176, 3175, 1, 0, 0, 0, 3177, 187, + 1, 0, 0, 0, 3178, 3179, 5, 400, 0, 0, 3179, 3180, 3, 624, 312, 0, 3180, + 189, 1, 0, 0, 0, 3181, 3186, 3, 218, 109, 0, 3182, 3186, 3, 220, 110, 0, + 3183, 3186, 3, 222, 111, 0, 3184, 3186, 3, 224, 112, 0, 3185, 3181, 1, + 0, 0, 0, 3185, 3182, 1, 0, 0, 0, 3185, 3183, 1, 0, 0, 0, 3185, 3184, 1, + 0, 0, 0, 3186, 191, 1, 0, 0, 0, 3187, 3189, 5, 85, 0, 0, 3188, 3190, 7, + 39, 0, 0, 3189, 3188, 1, 0, 0, 0, 3189, 3190, 1, 0, 0, 0, 3190, 3192, 1, + 0, 0, 0, 3191, 3193, 5, 78, 0, 0, 3192, 3191, 1, 0, 0, 0, 3192, 3193, 1, + 0, 0, 0, 3193, 3195, 1, 0, 0, 0, 3194, 3196, 5, 87, 0, 0, 3195, 3194, 1, + 0, 0, 0, 3195, 3196, 1, 0, 0, 0, 3196, 3197, 1, 0, 0, 0, 3197, 3204, 3, + 552, 276, 0, 3198, 3199, 5, 129, 0, 0, 3199, 3201, 5, 1138, 0, 0, 3200, + 3202, 3, 616, 308, 0, 3201, 3200, 1, 0, 0, 0, 3201, 3202, 1, 0, 0, 0, 3202, + 3203, 1, 0, 0, 0, 3203, 3205, 5, 1139, 0, 0, 3204, 3198, 1, 0, 0, 0, 3204, + 3205, 1, 0, 0, 0, 3205, 3229, 1, 0, 0, 0, 3206, 3208, 5, 1138, 0, 0, 3207, + 3209, 3, 618, 309, 0, 3208, 3207, 1, 0, 0, 0, 3208, 3209, 1, 0, 0, 0, 3209, + 3210, 1, 0, 0, 0, 3210, 3212, 5, 1139, 0, 0, 3211, 3206, 1, 0, 0, 0, 3211, + 3212, 1, 0, 0, 0, 3212, 3213, 1, 0, 0, 0, 3213, 3218, 3, 206, 103, 0, 3214, + 3216, 5, 12, 0, 0, 3215, 3214, 1, 0, 0, 0, 3215, 3216, 1, 0, 0, 0, 3216, + 3217, 1, 0, 0, 0, 3217, 3219, 3, 584, 292, 0, 3218, 3215, 1, 0, 0, 0, 3218, + 3219, 1, 0, 0, 0, 3219, 3230, 1, 0, 0, 0, 3220, 3221, 5, 153, 0, 0, 3221, + 3226, 3, 208, 104, 0, 3222, 3223, 5, 1140, 0, 0, 3223, 3225, 3, 208, 104, + 0, 3224, 3222, 1, 0, 0, 0, 3225, 3228, 1, 0, 0, 0, 3226, 3224, 1, 0, 0, + 0, 3226, 3227, 1, 0, 0, 0, 3227, 3230, 1, 0, 0, 0, 3228, 3226, 1, 0, 0, + 0, 3229, 3211, 1, 0, 0, 0, 3229, 3220, 1, 0, 0, 0, 3230, 3243, 1, 0, 0, + 0, 3231, 3232, 5, 118, 0, 0, 3232, 3233, 5, 402, 0, 0, 3233, 3234, 5, 91, + 0, 0, 3234, 3235, 5, 184, 0, 0, 3235, 3240, 3, 208, 104, 0, 3236, 3237, + 5, 1140, 0, 0, 3237, 3239, 3, 208, 104, 0, 3238, 3236, 1, 0, 0, 0, 3239, + 3242, 1, 0, 0, 0, 3240, 3238, 1, 0, 0, 0, 3240, 3241, 1, 0, 0, 0, 3241, + 3244, 1, 0, 0, 0, 3242, 3240, 1, 0, 0, 0, 3243, 3231, 1, 0, 0, 0, 3243, + 3244, 1, 0, 0, 0, 3244, 193, 1, 0, 0, 0, 3245, 3246, 5, 102, 0, 0, 3246, + 3248, 5, 389, 0, 0, 3247, 3249, 7, 40, 0, 0, 3248, 3247, 1, 0, 0, 0, 3248, + 3249, 1, 0, 0, 0, 3249, 3251, 1, 0, 0, 0, 3250, 3252, 5, 475, 0, 0, 3251, + 3250, 1, 0, 0, 0, 3251, 3252, 1, 0, 0, 0, 3252, 3253, 1, 0, 0, 0, 3253, + 3254, 5, 82, 0, 0, 3254, 3256, 5, 1153, 0, 0, 3255, 3257, 7, 6, 0, 0, 3256, + 3255, 1, 0, 0, 0, 3256, 3257, 1, 0, 0, 0, 3257, 3258, 1, 0, 0, 0, 3258, + 3259, 5, 87, 0, 0, 3259, 3260, 5, 172, 0, 0, 3260, 3266, 3, 552, 276, 0, + 3261, 3262, 5, 129, 0, 0, 3262, 3263, 5, 1138, 0, 0, 3263, 3264, 3, 616, + 308, 0, 3264, 3265, 5, 1139, 0, 0, 3265, 3267, 1, 0, 0, 0, 3266, 3261, + 1, 0, 0, 0, 3266, 3267, 1, 0, 0, 0, 3267, 3271, 1, 0, 0, 0, 3268, 3269, + 5, 25, 0, 0, 3269, 3270, 5, 153, 0, 0, 3270, 3272, 3, 568, 284, 0, 3271, + 3268, 1, 0, 0, 0, 3271, 3272, 1, 0, 0, 0, 3272, 3279, 1, 0, 0, 0, 3273, + 3275, 7, 41, 0, 0, 3274, 3276, 3, 280, 140, 0, 3275, 3274, 1, 0, 0, 0, + 3276, 3277, 1, 0, 0, 0, 3277, 3275, 1, 0, 0, 0, 3277, 3278, 1, 0, 0, 0, + 3278, 3280, 1, 0, 0, 0, 3279, 3273, 1, 0, 0, 0, 3279, 3280, 1, 0, 0, 0, + 3280, 3287, 1, 0, 0, 0, 3281, 3283, 5, 101, 0, 0, 3282, 3284, 3, 282, 141, + 0, 3283, 3282, 1, 0, 0, 0, 3284, 3285, 1, 0, 0, 0, 3285, 3283, 1, 0, 0, + 0, 3285, 3286, 1, 0, 0, 0, 3286, 3288, 1, 0, 0, 0, 3287, 3281, 1, 0, 0, + 0, 3287, 3288, 1, 0, 0, 0, 3288, 3293, 1, 0, 0, 0, 3289, 3290, 5, 78, 0, + 0, 3290, 3291, 3, 590, 295, 0, 3291, 3292, 7, 42, 0, 0, 3292, 3294, 1, + 0, 0, 0, 3293, 3289, 1, 0, 0, 0, 3293, 3294, 1, 0, 0, 0, 3294, 3306, 1, + 0, 0, 0, 3295, 3296, 5, 1138, 0, 0, 3296, 3301, 3, 210, 105, 0, 3297, 3298, + 5, 1140, 0, 0, 3298, 3300, 3, 210, 105, 0, 3299, 3297, 1, 0, 0, 0, 3300, + 3303, 1, 0, 0, 0, 3301, 3299, 1, 0, 0, 0, 3301, 3302, 1, 0, 0, 0, 3302, + 3304, 1, 0, 0, 0, 3303, 3301, 1, 0, 0, 0, 3304, 3305, 5, 1139, 0, 0, 3305, + 3307, 1, 0, 0, 0, 3306, 3295, 1, 0, 0, 0, 3306, 3307, 1, 0, 0, 0, 3307, + 3317, 1, 0, 0, 0, 3308, 3309, 5, 153, 0, 0, 3309, 3314, 3, 208, 104, 0, + 3310, 3311, 5, 1140, 0, 0, 3311, 3313, 3, 208, 104, 0, 3312, 3310, 1, 0, + 0, 0, 3313, 3316, 1, 0, 0, 0, 3314, 3312, 1, 0, 0, 0, 3314, 3315, 1, 0, + 0, 0, 3315, 3318, 1, 0, 0, 0, 3316, 3314, 1, 0, 0, 0, 3317, 3308, 1, 0, + 0, 0, 3317, 3318, 1, 0, 0, 0, 3318, 195, 1, 0, 0, 0, 3319, 3320, 5, 102, + 0, 0, 3320, 3322, 5, 683, 0, 0, 3321, 3323, 7, 40, 0, 0, 3322, 3321, 1, + 0, 0, 0, 3322, 3323, 1, 0, 0, 0, 3323, 3325, 1, 0, 0, 0, 3324, 3326, 5, + 475, 0, 0, 3325, 3324, 1, 0, 0, 0, 3325, 3326, 1, 0, 0, 0, 3326, 3327, + 1, 0, 0, 0, 3327, 3328, 5, 82, 0, 0, 3328, 3330, 5, 1153, 0, 0, 3329, 3331, + 7, 6, 0, 0, 3330, 3329, 1, 0, 0, 0, 3330, 3331, 1, 0, 0, 0, 3331, 3332, + 1, 0, 0, 0, 3332, 3333, 5, 87, 0, 0, 3333, 3334, 5, 172, 0, 0, 3334, 3338, + 3, 552, 276, 0, 3335, 3336, 5, 25, 0, 0, 3336, 3337, 5, 153, 0, 0, 3337, + 3339, 3, 568, 284, 0, 3338, 3335, 1, 0, 0, 0, 3338, 3339, 1, 0, 0, 0, 3339, + 3346, 1, 0, 0, 0, 3340, 3341, 5, 602, 0, 0, 3341, 3342, 5, 449, 0, 0, 3342, + 3343, 5, 19, 0, 0, 3343, 3344, 5, 1131, 0, 0, 3344, 3345, 5, 1153, 0, 0, + 3345, 3347, 5, 1130, 0, 0, 3346, 3340, 1, 0, 0, 0, 3346, 3347, 1, 0, 0, + 0, 3347, 3352, 1, 0, 0, 0, 3348, 3349, 5, 78, 0, 0, 3349, 3350, 3, 590, + 295, 0, 3350, 3351, 7, 42, 0, 0, 3351, 3353, 1, 0, 0, 0, 3352, 3348, 1, + 0, 0, 0, 3352, 3353, 1, 0, 0, 0, 3353, 3365, 1, 0, 0, 0, 3354, 3355, 5, + 1138, 0, 0, 3355, 3360, 3, 210, 105, 0, 3356, 3357, 5, 1140, 0, 0, 3357, + 3359, 3, 210, 105, 0, 3358, 3356, 1, 0, 0, 0, 3359, 3362, 1, 0, 0, 0, 3360, + 3358, 1, 0, 0, 0, 3360, 3361, 1, 0, 0, 0, 3361, 3363, 1, 0, 0, 0, 3362, + 3360, 1, 0, 0, 0, 3363, 3364, 5, 1139, 0, 0, 3364, 3366, 1, 0, 0, 0, 3365, + 3354, 1, 0, 0, 0, 3365, 3366, 1, 0, 0, 0, 3366, 3376, 1, 0, 0, 0, 3367, + 3368, 5, 153, 0, 0, 3368, 3373, 3, 208, 104, 0, 3369, 3370, 5, 1140, 0, + 0, 3370, 3372, 3, 208, 104, 0, 3371, 3369, 1, 0, 0, 0, 3372, 3375, 1, 0, + 0, 0, 3373, 3371, 1, 0, 0, 0, 3373, 3374, 1, 0, 0, 0, 3374, 3377, 1, 0, + 0, 0, 3375, 3373, 1, 0, 0, 0, 3376, 3367, 1, 0, 0, 0, 3376, 3377, 1, 0, + 0, 0, 3377, 197, 1, 0, 0, 0, 3378, 3380, 5, 141, 0, 0, 3379, 3381, 7, 43, + 0, 0, 3380, 3379, 1, 0, 0, 0, 3380, 3381, 1, 0, 0, 0, 3381, 3383, 1, 0, + 0, 0, 3382, 3384, 5, 87, 0, 0, 3383, 3382, 1, 0, 0, 0, 3383, 3384, 1, 0, + 0, 0, 3384, 3385, 1, 0, 0, 0, 3385, 3391, 3, 552, 276, 0, 3386, 3387, 5, + 129, 0, 0, 3387, 3388, 5, 1138, 0, 0, 3388, 3389, 3, 616, 308, 0, 3389, + 3390, 5, 1139, 0, 0, 3390, 3392, 1, 0, 0, 0, 3391, 3386, 1, 0, 0, 0, 3391, + 3392, 1, 0, 0, 0, 3392, 3409, 1, 0, 0, 0, 3393, 3394, 5, 1138, 0, 0, 3394, + 3395, 3, 616, 308, 0, 3395, 3396, 5, 1139, 0, 0, 3396, 3398, 1, 0, 0, 0, + 3397, 3393, 1, 0, 0, 0, 3397, 3398, 1, 0, 0, 0, 3398, 3399, 1, 0, 0, 0, + 3399, 3410, 3, 206, 103, 0, 3400, 3401, 5, 153, 0, 0, 3401, 3406, 3, 208, + 104, 0, 3402, 3403, 5, 1140, 0, 0, 3403, 3405, 3, 208, 104, 0, 3404, 3402, + 1, 0, 0, 0, 3405, 3408, 1, 0, 0, 0, 3406, 3404, 1, 0, 0, 0, 3406, 3407, + 1, 0, 0, 0, 3407, 3410, 1, 0, 0, 0, 3408, 3406, 1, 0, 0, 0, 3409, 3397, + 1, 0, 0, 0, 3409, 3400, 1, 0, 0, 0, 3410, 199, 1, 0, 0, 0, 3411, 3413, + 3, 252, 126, 0, 3412, 3414, 3, 212, 106, 0, 3413, 3412, 1, 0, 0, 0, 3413, + 3414, 1, 0, 0, 0, 3414, 3477, 1, 0, 0, 0, 3415, 3417, 3, 248, 124, 0, 3416, + 3418, 3, 212, 106, 0, 3417, 3416, 1, 0, 0, 0, 3417, 3418, 1, 0, 0, 0, 3418, + 3477, 1, 0, 0, 0, 3419, 3422, 3, 254, 127, 0, 3420, 3422, 3, 250, 125, + 0, 3421, 3419, 1, 0, 0, 0, 3421, 3420, 1, 0, 0, 0, 3422, 3424, 1, 0, 0, + 0, 3423, 3425, 3, 258, 129, 0, 3424, 3423, 1, 0, 0, 0, 3425, 3426, 1, 0, + 0, 0, 3426, 3424, 1, 0, 0, 0, 3426, 3427, 1, 0, 0, 0, 3427, 3436, 1, 0, + 0, 0, 3428, 3430, 5, 180, 0, 0, 3429, 3431, 7, 44, 0, 0, 3430, 3429, 1, + 0, 0, 0, 3430, 3431, 1, 0, 0, 0, 3431, 3434, 1, 0, 0, 0, 3432, 3435, 3, + 252, 126, 0, 3433, 3435, 3, 248, 124, 0, 3434, 3432, 1, 0, 0, 0, 3434, + 3433, 1, 0, 0, 0, 3435, 3437, 1, 0, 0, 0, 3436, 3428, 1, 0, 0, 0, 3436, + 3437, 1, 0, 0, 0, 3437, 3439, 1, 0, 0, 0, 3438, 3440, 3, 230, 115, 0, 3439, + 3438, 1, 0, 0, 0, 3439, 3440, 1, 0, 0, 0, 3440, 3442, 1, 0, 0, 0, 3441, + 3443, 3, 294, 147, 0, 3442, 3441, 1, 0, 0, 0, 3442, 3443, 1, 0, 0, 0, 3443, + 3445, 1, 0, 0, 0, 3444, 3446, 3, 212, 106, 0, 3445, 3444, 1, 0, 0, 0, 3445, + 3446, 1, 0, 0, 0, 3446, 3477, 1, 0, 0, 0, 3447, 3449, 3, 250, 125, 0, 3448, + 3450, 3, 256, 128, 0, 3449, 3448, 1, 0, 0, 0, 3450, 3451, 1, 0, 0, 0, 3451, + 3449, 1, 0, 0, 0, 3451, 3452, 1, 0, 0, 0, 3452, 3458, 1, 0, 0, 0, 3453, + 3455, 5, 180, 0, 0, 3454, 3456, 7, 44, 0, 0, 3455, 3454, 1, 0, 0, 0, 3455, + 3456, 1, 0, 0, 0, 3456, 3457, 1, 0, 0, 0, 3457, 3459, 3, 248, 124, 0, 3458, + 3453, 1, 0, 0, 0, 3458, 3459, 1, 0, 0, 0, 3459, 3461, 1, 0, 0, 0, 3460, + 3462, 3, 230, 115, 0, 3461, 3460, 1, 0, 0, 0, 3461, 3462, 1, 0, 0, 0, 3462, + 3464, 1, 0, 0, 0, 3463, 3465, 3, 294, 147, 0, 3464, 3463, 1, 0, 0, 0, 3464, + 3465, 1, 0, 0, 0, 3465, 3467, 1, 0, 0, 0, 3466, 3468, 3, 212, 106, 0, 3467, + 3466, 1, 0, 0, 0, 3467, 3468, 1, 0, 0, 0, 3468, 3477, 1, 0, 0, 0, 3469, + 3472, 3, 254, 127, 0, 3470, 3471, 5, 1140, 0, 0, 3471, 3473, 3, 260, 130, + 0, 3472, 3470, 1, 0, 0, 0, 3473, 3474, 1, 0, 0, 0, 3474, 3472, 1, 0, 0, + 0, 3474, 3475, 1, 0, 0, 0, 3475, 3477, 1, 0, 0, 0, 3476, 3411, 1, 0, 0, + 0, 3476, 3415, 1, 0, 0, 0, 3476, 3421, 1, 0, 0, 0, 3476, 3447, 1, 0, 0, + 0, 3476, 3469, 1, 0, 0, 0, 3477, 201, 1, 0, 0, 0, 3478, 3481, 3, 226, 113, + 0, 3479, 3481, 3, 228, 114, 0, 3480, 3478, 1, 0, 0, 0, 3480, 3479, 1, 0, + 0, 0, 3481, 203, 1, 0, 0, 0, 3482, 3483, 5, 188, 0, 0, 3483, 3485, 5, 1138, + 0, 0, 3484, 3486, 3, 626, 313, 0, 3485, 3484, 1, 0, 0, 0, 3485, 3486, 1, + 0, 0, 0, 3486, 3487, 1, 0, 0, 0, 3487, 3496, 5, 1139, 0, 0, 3488, 3489, + 5, 1140, 0, 0, 3489, 3491, 5, 1138, 0, 0, 3490, 3492, 3, 626, 313, 0, 3491, + 3490, 1, 0, 0, 0, 3491, 3492, 1, 0, 0, 0, 3492, 3493, 1, 0, 0, 0, 3493, + 3495, 5, 1139, 0, 0, 3494, 3488, 1, 0, 0, 0, 3495, 3498, 1, 0, 0, 0, 3496, + 3494, 1, 0, 0, 0, 3496, 3497, 1, 0, 0, 0, 3497, 205, 1, 0, 0, 0, 3498, + 3496, 1, 0, 0, 0, 3499, 3518, 3, 200, 100, 0, 3500, 3501, 7, 45, 0, 0, + 3501, 3503, 5, 1138, 0, 0, 3502, 3504, 3, 626, 313, 0, 3503, 3502, 1, 0, + 0, 0, 3503, 3504, 1, 0, 0, 0, 3504, 3505, 1, 0, 0, 0, 3505, 3514, 5, 1139, + 0, 0, 3506, 3507, 5, 1140, 0, 0, 3507, 3509, 5, 1138, 0, 0, 3508, 3510, + 3, 626, 313, 0, 3509, 3508, 1, 0, 0, 0, 3509, 3510, 1, 0, 0, 0, 3510, 3511, + 1, 0, 0, 0, 3511, 3513, 5, 1139, 0, 0, 3512, 3506, 1, 0, 0, 0, 3513, 3516, + 1, 0, 0, 0, 3514, 3512, 1, 0, 0, 0, 3514, 3515, 1, 0, 0, 0, 3515, 3518, + 1, 0, 0, 0, 3516, 3514, 1, 0, 0, 0, 3517, 3499, 1, 0, 0, 0, 3517, 3500, + 1, 0, 0, 0, 3518, 207, 1, 0, 0, 0, 3519, 3520, 3, 556, 278, 0, 3520, 3523, + 5, 1129, 0, 0, 3521, 3524, 3, 688, 344, 0, 3522, 3524, 5, 42, 0, 0, 3523, + 3521, 1, 0, 0, 0, 3523, 3522, 1, 0, 0, 0, 3524, 209, 1, 0, 0, 0, 3525, + 3528, 3, 584, 292, 0, 3526, 3528, 5, 1164, 0, 0, 3527, 3525, 1, 0, 0, 0, + 3527, 3526, 1, 0, 0, 0, 3528, 211, 1, 0, 0, 0, 3529, 3530, 5, 65, 0, 0, + 3530, 3536, 5, 184, 0, 0, 3531, 3532, 5, 103, 0, 0, 3532, 3533, 5, 80, + 0, 0, 3533, 3534, 5, 611, 0, 0, 3534, 3536, 5, 512, 0, 0, 3535, 3529, 1, + 0, 0, 0, 3535, 3531, 1, 0, 0, 0, 3536, 213, 1, 0, 0, 0, 3537, 3539, 5, + 44, 0, 0, 3538, 3540, 5, 106, 0, 0, 3539, 3538, 1, 0, 0, 0, 3539, 3540, + 1, 0, 0, 0, 3540, 3542, 1, 0, 0, 0, 3541, 3543, 5, 569, 0, 0, 3542, 3541, + 1, 0, 0, 0, 3542, 3543, 1, 0, 0, 0, 3543, 3545, 1, 0, 0, 0, 3544, 3546, + 5, 78, 0, 0, 3545, 3544, 1, 0, 0, 0, 3545, 3546, 1, 0, 0, 0, 3546, 3547, + 1, 0, 0, 0, 3547, 3548, 5, 68, 0, 0, 3548, 3553, 3, 552, 276, 0, 3549, + 3551, 5, 12, 0, 0, 3550, 3549, 1, 0, 0, 0, 3550, 3551, 1, 0, 0, 0, 3551, + 3552, 1, 0, 0, 0, 3552, 3554, 3, 584, 292, 0, 3553, 3550, 1, 0, 0, 0, 3553, + 3554, 1, 0, 0, 0, 3554, 3560, 1, 0, 0, 0, 3555, 3556, 5, 129, 0, 0, 3556, + 3557, 5, 1138, 0, 0, 3557, 3558, 3, 616, 308, 0, 3558, 3559, 5, 1139, 0, + 0, 3559, 3561, 1, 0, 0, 0, 3560, 3555, 1, 0, 0, 0, 3560, 3561, 1, 0, 0, + 0, 3561, 3564, 1, 0, 0, 0, 3562, 3563, 5, 190, 0, 0, 3563, 3565, 3, 688, + 344, 0, 3564, 3562, 1, 0, 0, 0, 3564, 3565, 1, 0, 0, 0, 3565, 3567, 1, + 0, 0, 0, 3566, 3568, 3, 230, 115, 0, 3567, 3566, 1, 0, 0, 0, 3567, 3568, + 1, 0, 0, 0, 3568, 3571, 1, 0, 0, 0, 3569, 3570, 5, 99, 0, 0, 3570, 3572, + 3, 296, 148, 0, 3571, 3569, 1, 0, 0, 0, 3571, 3572, 1, 0, 0, 0, 3572, 215, + 1, 0, 0, 0, 3573, 3575, 5, 44, 0, 0, 3574, 3576, 5, 106, 0, 0, 3575, 3574, + 1, 0, 0, 0, 3575, 3576, 1, 0, 0, 0, 3576, 3578, 1, 0, 0, 0, 3577, 3579, + 5, 569, 0, 0, 3578, 3577, 1, 0, 0, 0, 3578, 3579, 1, 0, 0, 0, 3579, 3581, + 1, 0, 0, 0, 3580, 3582, 5, 78, 0, 0, 3581, 3580, 1, 0, 0, 0, 3581, 3582, + 1, 0, 0, 0, 3582, 3622, 1, 0, 0, 0, 3583, 3586, 3, 552, 276, 0, 3584, 3585, + 5, 1137, 0, 0, 3585, 3587, 5, 1122, 0, 0, 3586, 3584, 1, 0, 0, 0, 3586, + 3587, 1, 0, 0, 0, 3587, 3596, 1, 0, 0, 0, 3588, 3589, 5, 1140, 0, 0, 3589, + 3592, 3, 552, 276, 0, 3590, 3591, 5, 1137, 0, 0, 3591, 3593, 5, 1122, 0, + 0, 3592, 3590, 1, 0, 0, 0, 3592, 3593, 1, 0, 0, 0, 3593, 3595, 1, 0, 0, + 0, 3594, 3588, 1, 0, 0, 0, 3595, 3598, 1, 0, 0, 0, 3596, 3594, 1, 0, 0, + 0, 3596, 3597, 1, 0, 0, 0, 3597, 3599, 1, 0, 0, 0, 3598, 3596, 1, 0, 0, + 0, 3599, 3600, 5, 68, 0, 0, 3600, 3601, 3, 234, 117, 0, 3601, 3623, 1, + 0, 0, 0, 3602, 3603, 5, 68, 0, 0, 3603, 3606, 3, 552, 276, 0, 3604, 3605, + 5, 1137, 0, 0, 3605, 3607, 5, 1122, 0, 0, 3606, 3604, 1, 0, 0, 0, 3606, + 3607, 1, 0, 0, 0, 3607, 3616, 1, 0, 0, 0, 3608, 3609, 5, 1140, 0, 0, 3609, + 3612, 3, 552, 276, 0, 3610, 3611, 5, 1137, 0, 0, 3611, 3613, 5, 1122, 0, + 0, 3612, 3610, 1, 0, 0, 0, 3612, 3613, 1, 0, 0, 0, 3613, 3615, 1, 0, 0, + 0, 3614, 3608, 1, 0, 0, 0, 3615, 3618, 1, 0, 0, 0, 3616, 3614, 1, 0, 0, + 0, 3616, 3617, 1, 0, 0, 0, 3617, 3619, 1, 0, 0, 0, 3618, 3616, 1, 0, 0, + 0, 3619, 3620, 5, 187, 0, 0, 3620, 3621, 3, 234, 117, 0, 3621, 3623, 1, + 0, 0, 0, 3622, 3583, 1, 0, 0, 0, 3622, 3602, 1, 0, 0, 0, 3623, 3626, 1, + 0, 0, 0, 3624, 3625, 5, 190, 0, 0, 3625, 3627, 3, 688, 344, 0, 3626, 3624, + 1, 0, 0, 0, 3626, 3627, 1, 0, 0, 0, 3627, 217, 1, 0, 0, 0, 3628, 3629, + 5, 443, 0, 0, 3629, 3630, 3, 552, 276, 0, 3630, 3635, 5, 540, 0, 0, 3631, + 3633, 5, 12, 0, 0, 3632, 3631, 1, 0, 0, 0, 3632, 3633, 1, 0, 0, 0, 3633, + 3634, 1, 0, 0, 0, 3634, 3636, 3, 584, 292, 0, 3635, 3632, 1, 0, 0, 0, 3635, + 3636, 1, 0, 0, 0, 3636, 219, 1, 0, 0, 0, 3637, 3638, 5, 443, 0, 0, 3638, + 3639, 3, 552, 276, 0, 3639, 3640, 5, 134, 0, 0, 3640, 3647, 3, 584, 292, + 0, 3641, 3642, 3, 696, 348, 0, 3642, 3643, 5, 1138, 0, 0, 3643, 3644, 3, + 628, 314, 0, 3644, 3645, 5, 1139, 0, 0, 3645, 3648, 1, 0, 0, 0, 3646, 3648, + 7, 46, 0, 0, 3647, 3641, 1, 0, 0, 0, 3647, 3646, 1, 0, 0, 0, 3648, 3651, + 1, 0, 0, 0, 3649, 3650, 5, 190, 0, 0, 3650, 3652, 3, 688, 344, 0, 3651, + 3649, 1, 0, 0, 0, 3651, 3652, 1, 0, 0, 0, 3652, 3655, 1, 0, 0, 0, 3653, + 3654, 5, 99, 0, 0, 3654, 3656, 3, 296, 148, 0, 3655, 3653, 1, 0, 0, 0, + 3655, 3656, 1, 0, 0, 0, 3656, 221, 1, 0, 0, 0, 3657, 3658, 5, 443, 0, 0, + 3658, 3659, 3, 552, 276, 0, 3659, 3660, 5, 134, 0, 0, 3660, 3663, 7, 47, + 0, 0, 3661, 3662, 5, 190, 0, 0, 3662, 3664, 3, 688, 344, 0, 3663, 3661, + 1, 0, 0, 0, 3663, 3664, 1, 0, 0, 0, 3664, 3667, 1, 0, 0, 0, 3665, 3666, + 5, 99, 0, 0, 3666, 3668, 3, 296, 148, 0, 3667, 3665, 1, 0, 0, 0, 3667, + 3668, 1, 0, 0, 0, 3668, 223, 1, 0, 0, 0, 3669, 3670, 5, 443, 0, 0, 3670, + 3671, 3, 552, 276, 0, 3671, 3672, 5, 362, 0, 0, 3672, 225, 1, 0, 0, 0, + 3673, 3675, 5, 184, 0, 0, 3674, 3676, 5, 106, 0, 0, 3675, 3674, 1, 0, 0, + 0, 3675, 3676, 1, 0, 0, 0, 3676, 3678, 1, 0, 0, 0, 3677, 3679, 5, 78, 0, + 0, 3678, 3677, 1, 0, 0, 0, 3678, 3679, 1, 0, 0, 0, 3679, 3680, 1, 0, 0, + 0, 3680, 3685, 3, 552, 276, 0, 3681, 3683, 5, 12, 0, 0, 3682, 3681, 1, + 0, 0, 0, 3682, 3683, 1, 0, 0, 0, 3683, 3684, 1, 0, 0, 0, 3684, 3686, 3, + 584, 292, 0, 3685, 3682, 1, 0, 0, 0, 3685, 3686, 1, 0, 0, 0, 3686, 3687, + 1, 0, 0, 0, 3687, 3688, 5, 153, 0, 0, 3688, 3693, 3, 208, 104, 0, 3689, + 3690, 5, 1140, 0, 0, 3690, 3692, 3, 208, 104, 0, 3691, 3689, 1, 0, 0, 0, + 3692, 3695, 1, 0, 0, 0, 3693, 3691, 1, 0, 0, 0, 3693, 3694, 1, 0, 0, 0, + 3694, 3698, 1, 0, 0, 0, 3695, 3693, 1, 0, 0, 0, 3696, 3697, 5, 190, 0, + 0, 3697, 3699, 3, 688, 344, 0, 3698, 3696, 1, 0, 0, 0, 3698, 3699, 1, 0, + 0, 0, 3699, 3701, 1, 0, 0, 0, 3700, 3702, 3, 230, 115, 0, 3701, 3700, 1, + 0, 0, 0, 3701, 3702, 1, 0, 0, 0, 3702, 3704, 1, 0, 0, 0, 3703, 3705, 3, + 294, 147, 0, 3704, 3703, 1, 0, 0, 0, 3704, 3705, 1, 0, 0, 0, 3705, 227, + 1, 0, 0, 0, 3706, 3708, 5, 184, 0, 0, 3707, 3709, 5, 106, 0, 0, 3708, 3707, + 1, 0, 0, 0, 3708, 3709, 1, 0, 0, 0, 3709, 3711, 1, 0, 0, 0, 3710, 3712, + 5, 78, 0, 0, 3711, 3710, 1, 0, 0, 0, 3711, 3712, 1, 0, 0, 0, 3712, 3713, + 1, 0, 0, 0, 3713, 3714, 3, 234, 117, 0, 3714, 3715, 5, 153, 0, 0, 3715, + 3720, 3, 208, 104, 0, 3716, 3717, 5, 1140, 0, 0, 3717, 3719, 3, 208, 104, + 0, 3718, 3716, 1, 0, 0, 0, 3719, 3722, 1, 0, 0, 0, 3720, 3718, 1, 0, 0, + 0, 3720, 3721, 1, 0, 0, 0, 3721, 3725, 1, 0, 0, 0, 3722, 3720, 1, 0, 0, + 0, 3723, 3724, 5, 190, 0, 0, 3724, 3726, 3, 688, 344, 0, 3725, 3723, 1, + 0, 0, 0, 3725, 3726, 1, 0, 0, 0, 3726, 229, 1, 0, 0, 0, 3727, 3728, 5, + 124, 0, 0, 3728, 3729, 5, 19, 0, 0, 3729, 3734, 3, 232, 116, 0, 3730, 3731, + 5, 1140, 0, 0, 3731, 3733, 3, 232, 116, 0, 3732, 3730, 1, 0, 0, 0, 3733, + 3736, 1, 0, 0, 0, 3734, 3732, 1, 0, 0, 0, 3734, 3735, 1, 0, 0, 0, 3735, + 231, 1, 0, 0, 0, 3736, 3734, 1, 0, 0, 0, 3737, 3739, 3, 688, 344, 0, 3738, + 3740, 7, 48, 0, 0, 3739, 3738, 1, 0, 0, 0, 3739, 3740, 1, 0, 0, 0, 3740, + 233, 1, 0, 0, 0, 3741, 3746, 3, 236, 118, 0, 3742, 3743, 5, 1140, 0, 0, + 3743, 3745, 3, 236, 118, 0, 3744, 3742, 1, 0, 0, 0, 3745, 3748, 1, 0, 0, + 0, 3746, 3744, 1, 0, 0, 0, 3746, 3747, 1, 0, 0, 0, 3747, 235, 1, 0, 0, + 0, 3748, 3746, 1, 0, 0, 0, 3749, 3753, 3, 238, 119, 0, 3750, 3752, 3, 244, + 122, 0, 3751, 3750, 1, 0, 0, 0, 3752, 3755, 1, 0, 0, 0, 3753, 3751, 1, + 0, 0, 0, 3753, 3754, 1, 0, 0, 0, 3754, 3768, 1, 0, 0, 0, 3755, 3753, 1, + 0, 0, 0, 3756, 3757, 5, 1138, 0, 0, 3757, 3761, 3, 238, 119, 0, 3758, 3760, + 3, 244, 122, 0, 3759, 3758, 1, 0, 0, 0, 3760, 3763, 1, 0, 0, 0, 3761, 3759, + 1, 0, 0, 0, 3761, 3762, 1, 0, 0, 0, 3762, 3764, 1, 0, 0, 0, 3763, 3761, + 1, 0, 0, 0, 3764, 3765, 5, 1139, 0, 0, 3765, 3768, 1, 0, 0, 0, 3766, 3768, + 3, 262, 131, 0, 3767, 3749, 1, 0, 0, 0, 3767, 3756, 1, 0, 0, 0, 3767, 3766, + 1, 0, 0, 0, 3768, 237, 1, 0, 0, 0, 3769, 3775, 3, 552, 276, 0, 3770, 3771, + 5, 129, 0, 0, 3771, 3772, 5, 1138, 0, 0, 3772, 3773, 3, 616, 308, 0, 3773, + 3774, 5, 1139, 0, 0, 3774, 3776, 1, 0, 0, 0, 3775, 3770, 1, 0, 0, 0, 3775, + 3776, 1, 0, 0, 0, 3776, 3781, 1, 0, 0, 0, 3777, 3779, 5, 12, 0, 0, 3778, + 3777, 1, 0, 0, 0, 3778, 3779, 1, 0, 0, 0, 3779, 3780, 1, 0, 0, 0, 3780, + 3782, 3, 584, 292, 0, 3781, 3778, 1, 0, 0, 0, 3781, 3782, 1, 0, 0, 0, 3782, + 3791, 1, 0, 0, 0, 3783, 3788, 3, 240, 120, 0, 3784, 3785, 5, 1140, 0, 0, + 3785, 3787, 3, 240, 120, 0, 3786, 3784, 1, 0, 0, 0, 3787, 3790, 1, 0, 0, + 0, 3788, 3786, 1, 0, 0, 0, 3788, 3789, 1, 0, 0, 0, 3789, 3792, 1, 0, 0, + 0, 3790, 3788, 1, 0, 0, 0, 3791, 3783, 1, 0, 0, 0, 3791, 3792, 1, 0, 0, + 0, 3792, 3810, 1, 0, 0, 0, 3793, 3799, 3, 200, 100, 0, 3794, 3795, 5, 1138, + 0, 0, 3795, 3796, 3, 200, 100, 0, 3796, 3797, 5, 1139, 0, 0, 3797, 3799, + 1, 0, 0, 0, 3798, 3793, 1, 0, 0, 0, 3798, 3794, 1, 0, 0, 0, 3799, 3801, + 1, 0, 0, 0, 3800, 3802, 5, 12, 0, 0, 3801, 3800, 1, 0, 0, 0, 3801, 3802, + 1, 0, 0, 0, 3802, 3803, 1, 0, 0, 0, 3803, 3804, 3, 584, 292, 0, 3804, 3810, + 1, 0, 0, 0, 3805, 3806, 5, 1138, 0, 0, 3806, 3807, 3, 234, 117, 0, 3807, + 3808, 5, 1139, 0, 0, 3808, 3810, 1, 0, 0, 0, 3809, 3769, 1, 0, 0, 0, 3809, + 3798, 1, 0, 0, 0, 3809, 3805, 1, 0, 0, 0, 3810, 239, 1, 0, 0, 0, 3811, + 3812, 7, 49, 0, 0, 3812, 3815, 7, 20, 0, 0, 3813, 3814, 5, 65, 0, 0, 3814, + 3816, 3, 242, 121, 0, 3815, 3813, 1, 0, 0, 0, 3815, 3816, 1, 0, 0, 0, 3816, + 3817, 1, 0, 0, 0, 3817, 3818, 5, 1138, 0, 0, 3818, 3819, 3, 616, 308, 0, + 3819, 3820, 5, 1139, 0, 0, 3820, 241, 1, 0, 0, 0, 3821, 3827, 5, 90, 0, + 0, 3822, 3823, 5, 124, 0, 0, 3823, 3827, 5, 19, 0, 0, 3824, 3825, 5, 73, + 0, 0, 3825, 3827, 5, 19, 0, 0, 3826, 3821, 1, 0, 0, 0, 3826, 3822, 1, 0, + 0, 0, 3826, 3824, 1, 0, 0, 0, 3827, 243, 1, 0, 0, 0, 3828, 3830, 7, 50, + 0, 0, 3829, 3828, 1, 0, 0, 0, 3829, 3830, 1, 0, 0, 0, 3830, 3831, 1, 0, + 0, 0, 3831, 3833, 5, 90, 0, 0, 3832, 3834, 5, 94, 0, 0, 3833, 3832, 1, + 0, 0, 0, 3833, 3834, 1, 0, 0, 0, 3834, 3835, 1, 0, 0, 0, 3835, 3839, 3, + 238, 119, 0, 3836, 3838, 3, 246, 123, 0, 3837, 3836, 1, 0, 0, 0, 3838, + 3841, 1, 0, 0, 0, 3839, 3837, 1, 0, 0, 0, 3839, 3840, 1, 0, 0, 0, 3840, + 3876, 1, 0, 0, 0, 3841, 3839, 1, 0, 0, 0, 3842, 3843, 5, 171, 0, 0, 3843, + 3848, 3, 238, 119, 0, 3844, 3845, 5, 118, 0, 0, 3845, 3847, 3, 688, 344, + 0, 3846, 3844, 1, 0, 0, 0, 3847, 3850, 1, 0, 0, 0, 3848, 3846, 1, 0, 0, + 0, 3848, 3849, 1, 0, 0, 0, 3849, 3876, 1, 0, 0, 0, 3850, 3848, 1, 0, 0, + 0, 3851, 3853, 7, 51, 0, 0, 3852, 3854, 5, 126, 0, 0, 3853, 3852, 1, 0, + 0, 0, 3853, 3854, 1, 0, 0, 0, 3854, 3855, 1, 0, 0, 0, 3855, 3857, 5, 90, + 0, 0, 3856, 3858, 5, 94, 0, 0, 3857, 3856, 1, 0, 0, 0, 3857, 3858, 1, 0, + 0, 0, 3858, 3859, 1, 0, 0, 0, 3859, 3863, 3, 238, 119, 0, 3860, 3862, 3, + 246, 123, 0, 3861, 3860, 1, 0, 0, 0, 3862, 3865, 1, 0, 0, 0, 3863, 3861, + 1, 0, 0, 0, 3863, 3864, 1, 0, 0, 0, 3864, 3876, 1, 0, 0, 0, 3865, 3863, + 1, 0, 0, 0, 3866, 3871, 5, 113, 0, 0, 3867, 3869, 7, 51, 0, 0, 3868, 3870, + 5, 126, 0, 0, 3869, 3868, 1, 0, 0, 0, 3869, 3870, 1, 0, 0, 0, 3870, 3872, + 1, 0, 0, 0, 3871, 3867, 1, 0, 0, 0, 3871, 3872, 1, 0, 0, 0, 3872, 3873, + 1, 0, 0, 0, 3873, 3874, 5, 90, 0, 0, 3874, 3876, 3, 238, 119, 0, 3875, + 3829, 1, 0, 0, 0, 3875, 3842, 1, 0, 0, 0, 3875, 3851, 1, 0, 0, 0, 3875, + 3866, 1, 0, 0, 0, 3876, 245, 1, 0, 0, 0, 3877, 3878, 5, 118, 0, 0, 3878, + 3885, 3, 688, 344, 0, 3879, 3880, 5, 187, 0, 0, 3880, 3881, 5, 1138, 0, + 0, 3881, 3882, 3, 616, 308, 0, 3882, 3883, 5, 1139, 0, 0, 3883, 3885, 1, + 0, 0, 0, 3884, 3877, 1, 0, 0, 0, 3884, 3879, 1, 0, 0, 0, 3885, 247, 1, + 0, 0, 0, 3886, 3887, 5, 1138, 0, 0, 3887, 3888, 3, 252, 126, 0, 3888, 3889, + 5, 1139, 0, 0, 3889, 3895, 1, 0, 0, 0, 3890, 3891, 5, 1138, 0, 0, 3891, + 3892, 3, 248, 124, 0, 3892, 3893, 5, 1139, 0, 0, 3893, 3895, 1, 0, 0, 0, + 3894, 3886, 1, 0, 0, 0, 3894, 3890, 1, 0, 0, 0, 3895, 249, 1, 0, 0, 0, + 3896, 3897, 5, 1138, 0, 0, 3897, 3898, 3, 254, 127, 0, 3898, 3899, 5, 1139, + 0, 0, 3899, 3905, 1, 0, 0, 0, 3900, 3901, 5, 1138, 0, 0, 3901, 3902, 3, + 250, 125, 0, 3902, 3903, 5, 1139, 0, 0, 3903, 3905, 1, 0, 0, 0, 3904, 3896, + 1, 0, 0, 0, 3904, 3900, 1, 0, 0, 0, 3905, 251, 1, 0, 0, 0, 3906, 3910, + 5, 152, 0, 0, 3907, 3909, 3, 272, 136, 0, 3908, 3907, 1, 0, 0, 0, 3909, + 3912, 1, 0, 0, 0, 3910, 3908, 1, 0, 0, 0, 3910, 3911, 1, 0, 0, 0, 3911, + 3913, 1, 0, 0, 0, 3912, 3910, 1, 0, 0, 0, 3913, 3915, 3, 274, 137, 0, 3914, + 3916, 3, 278, 139, 0, 3915, 3914, 1, 0, 0, 0, 3915, 3916, 1, 0, 0, 0, 3916, + 3917, 1, 0, 0, 0, 3917, 3919, 3, 284, 142, 0, 3918, 3920, 3, 286, 143, + 0, 3919, 3918, 1, 0, 0, 0, 3919, 3920, 1, 0, 0, 0, 3920, 3922, 1, 0, 0, + 0, 3921, 3923, 3, 288, 144, 0, 3922, 3921, 1, 0, 0, 0, 3922, 3923, 1, 0, + 0, 0, 3923, 3925, 1, 0, 0, 0, 3924, 3926, 3, 290, 145, 0, 3925, 3924, 1, + 0, 0, 0, 3925, 3926, 1, 0, 0, 0, 3926, 3928, 1, 0, 0, 0, 3927, 3929, 3, + 230, 115, 0, 3928, 3927, 1, 0, 0, 0, 3928, 3929, 1, 0, 0, 0, 3929, 3931, + 1, 0, 0, 0, 3930, 3932, 3, 294, 147, 0, 3931, 3930, 1, 0, 0, 0, 3931, 3932, + 1, 0, 0, 0, 3932, 3961, 1, 0, 0, 0, 3933, 3937, 5, 152, 0, 0, 3934, 3936, + 3, 272, 136, 0, 3935, 3934, 1, 0, 0, 0, 3936, 3939, 1, 0, 0, 0, 3937, 3935, + 1, 0, 0, 0, 3937, 3938, 1, 0, 0, 0, 3938, 3940, 1, 0, 0, 0, 3939, 3937, + 1, 0, 0, 0, 3940, 3941, 3, 274, 137, 0, 3941, 3943, 3, 284, 142, 0, 3942, + 3944, 3, 286, 143, 0, 3943, 3942, 1, 0, 0, 0, 3943, 3944, 1, 0, 0, 0, 3944, + 3946, 1, 0, 0, 0, 3945, 3947, 3, 288, 144, 0, 3946, 3945, 1, 0, 0, 0, 3946, + 3947, 1, 0, 0, 0, 3947, 3949, 1, 0, 0, 0, 3948, 3950, 3, 290, 145, 0, 3949, + 3948, 1, 0, 0, 0, 3949, 3950, 1, 0, 0, 0, 3950, 3952, 1, 0, 0, 0, 3951, + 3953, 3, 230, 115, 0, 3952, 3951, 1, 0, 0, 0, 3952, 3953, 1, 0, 0, 0, 3953, + 3955, 1, 0, 0, 0, 3954, 3956, 3, 294, 147, 0, 3955, 3954, 1, 0, 0, 0, 3955, + 3956, 1, 0, 0, 0, 3956, 3958, 1, 0, 0, 0, 3957, 3959, 3, 278, 139, 0, 3958, + 3957, 1, 0, 0, 0, 3958, 3959, 1, 0, 0, 0, 3959, 3961, 1, 0, 0, 0, 3960, + 3906, 1, 0, 0, 0, 3960, 3933, 1, 0, 0, 0, 3961, 253, 1, 0, 0, 0, 3962, + 3966, 5, 152, 0, 0, 3963, 3965, 3, 272, 136, 0, 3964, 3963, 1, 0, 0, 0, + 3965, 3968, 1, 0, 0, 0, 3966, 3964, 1, 0, 0, 0, 3966, 3967, 1, 0, 0, 0, + 3967, 3969, 1, 0, 0, 0, 3968, 3966, 1, 0, 0, 0, 3969, 3970, 3, 274, 137, + 0, 3970, 3972, 3, 284, 142, 0, 3971, 3973, 3, 286, 143, 0, 3972, 3971, + 1, 0, 0, 0, 3972, 3973, 1, 0, 0, 0, 3973, 3975, 1, 0, 0, 0, 3974, 3976, + 3, 288, 144, 0, 3975, 3974, 1, 0, 0, 0, 3975, 3976, 1, 0, 0, 0, 3976, 3978, + 1, 0, 0, 0, 3977, 3979, 3, 290, 145, 0, 3978, 3977, 1, 0, 0, 0, 3978, 3979, + 1, 0, 0, 0, 3979, 3981, 1, 0, 0, 0, 3980, 3982, 3, 230, 115, 0, 3981, 3980, + 1, 0, 0, 0, 3981, 3982, 1, 0, 0, 0, 3982, 3984, 1, 0, 0, 0, 3983, 3985, + 3, 294, 147, 0, 3984, 3983, 1, 0, 0, 0, 3984, 3985, 1, 0, 0, 0, 3985, 3987, + 1, 0, 0, 0, 3986, 3988, 3, 258, 129, 0, 3987, 3986, 1, 0, 0, 0, 3987, 3988, + 1, 0, 0, 0, 3988, 255, 1, 0, 0, 0, 3989, 3991, 5, 180, 0, 0, 3990, 3992, + 7, 44, 0, 0, 3991, 3990, 1, 0, 0, 0, 3991, 3992, 1, 0, 0, 0, 3992, 3993, + 1, 0, 0, 0, 3993, 3994, 3, 250, 125, 0, 3994, 257, 1, 0, 0, 0, 3995, 3997, + 5, 180, 0, 0, 3996, 3998, 7, 44, 0, 0, 3997, 3996, 1, 0, 0, 0, 3997, 3998, + 1, 0, 0, 0, 3998, 4001, 1, 0, 0, 0, 3999, 4002, 3, 254, 127, 0, 4000, 4002, + 3, 250, 125, 0, 4001, 3999, 1, 0, 0, 0, 4001, 4000, 1, 0, 0, 0, 4002, 259, + 1, 0, 0, 0, 4003, 4018, 5, 94, 0, 0, 4004, 4019, 3, 254, 127, 0, 4005, + 4019, 3, 250, 125, 0, 4006, 4009, 5, 1138, 0, 0, 4007, 4010, 3, 254, 127, + 0, 4008, 4010, 3, 250, 125, 0, 4009, 4007, 1, 0, 0, 0, 4009, 4008, 1, 0, + 0, 0, 4010, 4011, 1, 0, 0, 0, 4011, 4016, 5, 1139, 0, 0, 4012, 4014, 5, + 12, 0, 0, 4013, 4012, 1, 0, 0, 0, 4013, 4014, 1, 0, 0, 0, 4014, 4015, 1, + 0, 0, 0, 4015, 4017, 3, 584, 292, 0, 4016, 4013, 1, 0, 0, 0, 4016, 4017, + 1, 0, 0, 0, 4017, 4019, 1, 0, 0, 0, 4018, 4004, 1, 0, 0, 0, 4018, 4005, + 1, 0, 0, 0, 4018, 4006, 1, 0, 0, 0, 4019, 261, 1, 0, 0, 0, 4020, 4021, + 5, 279, 0, 0, 4021, 4022, 5, 1138, 0, 0, 4022, 4023, 5, 1153, 0, 0, 4023, + 4024, 5, 1140, 0, 0, 4024, 4025, 5, 1153, 0, 0, 4025, 4026, 5, 366, 0, + 0, 4026, 4027, 5, 1138, 0, 0, 4027, 4028, 3, 264, 132, 0, 4028, 4029, 5, + 1139, 0, 0, 4029, 4034, 5, 1139, 0, 0, 4030, 4032, 5, 12, 0, 0, 4031, 4030, + 1, 0, 0, 0, 4031, 4032, 1, 0, 0, 0, 4032, 4033, 1, 0, 0, 0, 4033, 4035, + 3, 584, 292, 0, 4034, 4031, 1, 0, 0, 0, 4034, 4035, 1, 0, 0, 0, 4035, 263, + 1, 0, 0, 0, 4036, 4041, 3, 266, 133, 0, 4037, 4038, 5, 1140, 0, 0, 4038, + 4040, 3, 266, 133, 0, 4039, 4037, 1, 0, 0, 0, 4040, 4043, 1, 0, 0, 0, 4041, + 4039, 1, 0, 0, 0, 4041, 4042, 1, 0, 0, 0, 4042, 265, 1, 0, 0, 0, 4043, + 4041, 1, 0, 0, 0, 4044, 4061, 3, 556, 278, 0, 4045, 4046, 5, 65, 0, 0, + 4046, 4062, 5, 285, 0, 0, 4047, 4059, 3, 604, 302, 0, 4048, 4049, 5, 286, + 0, 0, 4049, 4051, 5, 1153, 0, 0, 4050, 4052, 3, 268, 134, 0, 4051, 4050, + 1, 0, 0, 0, 4051, 4052, 1, 0, 0, 0, 4052, 4054, 1, 0, 0, 0, 4053, 4055, + 3, 270, 135, 0, 4054, 4053, 1, 0, 0, 0, 4054, 4055, 1, 0, 0, 0, 4055, 4060, + 1, 0, 0, 0, 4056, 4057, 5, 60, 0, 0, 4057, 4058, 5, 286, 0, 0, 4058, 4060, + 5, 1153, 0, 0, 4059, 4048, 1, 0, 0, 0, 4059, 4056, 1, 0, 0, 0, 4060, 4062, + 1, 0, 0, 0, 4061, 4045, 1, 0, 0, 0, 4061, 4047, 1, 0, 0, 0, 4062, 4074, + 1, 0, 0, 0, 4063, 4065, 5, 284, 0, 0, 4064, 4066, 5, 286, 0, 0, 4065, 4064, + 1, 0, 0, 0, 4065, 4066, 1, 0, 0, 0, 4066, 4067, 1, 0, 0, 0, 4067, 4068, + 5, 1153, 0, 0, 4068, 4069, 5, 366, 0, 0, 4069, 4070, 5, 1138, 0, 0, 4070, + 4071, 3, 264, 132, 0, 4071, 4072, 5, 1139, 0, 0, 4072, 4074, 1, 0, 0, 0, + 4073, 4044, 1, 0, 0, 0, 4073, 4063, 1, 0, 0, 0, 4074, 267, 1, 0, 0, 0, + 4075, 4080, 5, 116, 0, 0, 4076, 4080, 5, 412, 0, 0, 4077, 4078, 5, 42, + 0, 0, 4078, 4080, 3, 634, 317, 0, 4079, 4075, 1, 0, 0, 0, 4079, 4076, 1, + 0, 0, 0, 4079, 4077, 1, 0, 0, 0, 4080, 4081, 1, 0, 0, 0, 4081, 4082, 5, + 118, 0, 0, 4082, 4083, 5, 55, 0, 0, 4083, 269, 1, 0, 0, 0, 4084, 4089, + 5, 116, 0, 0, 4085, 4089, 5, 412, 0, 0, 4086, 4087, 5, 42, 0, 0, 4087, + 4089, 3, 634, 317, 0, 4088, 4084, 1, 0, 0, 0, 4088, 4085, 1, 0, 0, 0, 4088, + 4086, 1, 0, 0, 0, 4089, 4090, 1, 0, 0, 0, 4090, 4091, 5, 118, 0, 0, 4091, + 4092, 5, 412, 0, 0, 4092, 271, 1, 0, 0, 0, 4093, 4102, 7, 52, 0, 0, 4094, + 4102, 5, 75, 0, 0, 4095, 4102, 5, 171, 0, 0, 4096, 4102, 5, 166, 0, 0, + 4097, 4102, 5, 164, 0, 0, 4098, 4102, 5, 626, 0, 0, 4099, 4102, 7, 53, + 0, 0, 4100, 4102, 5, 165, 0, 0, 4101, 4093, 1, 0, 0, 0, 4101, 4094, 1, + 0, 0, 0, 4101, 4095, 1, 0, 0, 0, 4101, 4096, 1, 0, 0, 0, 4101, 4097, 1, + 0, 0, 0, 4101, 4098, 1, 0, 0, 0, 4101, 4099, 1, 0, 0, 0, 4101, 4100, 1, + 0, 0, 0, 4102, 273, 1, 0, 0, 0, 4103, 4106, 5, 1122, 0, 0, 4104, 4106, + 3, 276, 138, 0, 4105, 4103, 1, 0, 0, 0, 4105, 4104, 1, 0, 0, 0, 4106, 4111, + 1, 0, 0, 0, 4107, 4108, 5, 1140, 0, 0, 4108, 4110, 3, 276, 138, 0, 4109, + 4107, 1, 0, 0, 0, 4110, 4113, 1, 0, 0, 0, 4111, 4109, 1, 0, 0, 0, 4111, + 4112, 1, 0, 0, 0, 4112, 275, 1, 0, 0, 0, 4113, 4111, 1, 0, 0, 0, 4114, + 4115, 3, 550, 275, 0, 4115, 4116, 5, 1137, 0, 0, 4116, 4117, 5, 1122, 0, + 0, 4117, 4144, 1, 0, 0, 0, 4118, 4123, 3, 556, 278, 0, 4119, 4121, 5, 12, + 0, 0, 4120, 4119, 1, 0, 0, 0, 4120, 4121, 1, 0, 0, 0, 4121, 4122, 1, 0, + 0, 0, 4122, 4124, 3, 584, 292, 0, 4123, 4120, 1, 0, 0, 0, 4123, 4124, 1, + 0, 0, 0, 4124, 4144, 1, 0, 0, 0, 4125, 4130, 3, 648, 324, 0, 4126, 4128, + 5, 12, 0, 0, 4127, 4126, 1, 0, 0, 0, 4127, 4128, 1, 0, 0, 0, 4128, 4129, + 1, 0, 0, 0, 4129, 4131, 3, 584, 292, 0, 4130, 4127, 1, 0, 0, 0, 4130, 4131, + 1, 0, 0, 0, 4131, 4144, 1, 0, 0, 0, 4132, 4133, 5, 1164, 0, 0, 4133, 4135, + 5, 1113, 0, 0, 4134, 4132, 1, 0, 0, 0, 4134, 4135, 1, 0, 0, 0, 4135, 4136, + 1, 0, 0, 0, 4136, 4141, 3, 688, 344, 0, 4137, 4139, 5, 12, 0, 0, 4138, + 4137, 1, 0, 0, 0, 4138, 4139, 1, 0, 0, 0, 4139, 4140, 1, 0, 0, 0, 4140, + 4142, 3, 584, 292, 0, 4141, 4138, 1, 0, 0, 0, 4141, 4142, 1, 0, 0, 0, 4142, + 4144, 1, 0, 0, 0, 4143, 4114, 1, 0, 0, 0, 4143, 4118, 1, 0, 0, 0, 4143, + 4125, 1, 0, 0, 0, 4143, 4134, 1, 0, 0, 0, 4144, 277, 1, 0, 0, 0, 4145, + 4146, 5, 87, 0, 0, 4146, 4151, 3, 210, 105, 0, 4147, 4148, 5, 1140, 0, + 0, 4148, 4150, 3, 210, 105, 0, 4149, 4147, 1, 0, 0, 0, 4150, 4153, 1, 0, + 0, 0, 4151, 4149, 1, 0, 0, 0, 4151, 4152, 1, 0, 0, 0, 4152, 4182, 1, 0, + 0, 0, 4153, 4151, 1, 0, 0, 0, 4154, 4155, 5, 87, 0, 0, 4155, 4156, 5, 401, + 0, 0, 4156, 4182, 5, 1153, 0, 0, 4157, 4158, 5, 87, 0, 0, 4158, 4159, 5, + 127, 0, 0, 4159, 4163, 5, 1153, 0, 0, 4160, 4161, 5, 25, 0, 0, 4161, 4162, + 5, 153, 0, 0, 4162, 4164, 3, 568, 284, 0, 4163, 4160, 1, 0, 0, 0, 4163, + 4164, 1, 0, 0, 0, 4164, 4171, 1, 0, 0, 0, 4165, 4167, 7, 41, 0, 0, 4166, + 4168, 3, 280, 140, 0, 4167, 4166, 1, 0, 0, 0, 4168, 4169, 1, 0, 0, 0, 4169, + 4167, 1, 0, 0, 0, 4169, 4170, 1, 0, 0, 0, 4170, 4172, 1, 0, 0, 0, 4171, + 4165, 1, 0, 0, 0, 4171, 4172, 1, 0, 0, 0, 4172, 4179, 1, 0, 0, 0, 4173, + 4175, 5, 101, 0, 0, 4174, 4176, 3, 282, 141, 0, 4175, 4174, 1, 0, 0, 0, + 4176, 4177, 1, 0, 0, 0, 4177, 4175, 1, 0, 0, 0, 4177, 4178, 1, 0, 0, 0, + 4178, 4180, 1, 0, 0, 0, 4179, 4173, 1, 0, 0, 0, 4179, 4180, 1, 0, 0, 0, + 4180, 4182, 1, 0, 0, 0, 4181, 4145, 1, 0, 0, 0, 4181, 4154, 1, 0, 0, 0, + 4181, 4157, 1, 0, 0, 0, 4182, 279, 1, 0, 0, 0, 4183, 4184, 5, 173, 0, 0, + 4184, 4185, 5, 19, 0, 0, 4185, 4196, 5, 1153, 0, 0, 4186, 4188, 5, 122, + 0, 0, 4187, 4186, 1, 0, 0, 0, 4187, 4188, 1, 0, 0, 0, 4188, 4189, 1, 0, + 0, 0, 4189, 4190, 5, 56, 0, 0, 4190, 4191, 5, 19, 0, 0, 4191, 4196, 5, + 1153, 0, 0, 4192, 4193, 5, 58, 0, 0, 4193, 4194, 5, 19, 0, 0, 4194, 4196, + 5, 1153, 0, 0, 4195, 4183, 1, 0, 0, 0, 4195, 4187, 1, 0, 0, 0, 4195, 4192, + 1, 0, 0, 0, 4196, 281, 1, 0, 0, 0, 4197, 4198, 5, 169, 0, 0, 4198, 4199, + 5, 19, 0, 0, 4199, 4204, 5, 1153, 0, 0, 4200, 4201, 5, 173, 0, 0, 4201, + 4202, 5, 19, 0, 0, 4202, 4204, 5, 1153, 0, 0, 4203, 4197, 1, 0, 0, 0, 4203, + 4200, 1, 0, 0, 0, 4204, 283, 1, 0, 0, 0, 4205, 4206, 5, 68, 0, 0, 4206, + 4208, 3, 234, 117, 0, 4207, 4205, 1, 0, 0, 0, 4207, 4208, 1, 0, 0, 0, 4208, + 4211, 1, 0, 0, 0, 4209, 4210, 5, 190, 0, 0, 4210, 4212, 3, 688, 344, 0, + 4211, 4209, 1, 0, 0, 0, 4211, 4212, 1, 0, 0, 0, 4212, 285, 1, 0, 0, 0, + 4213, 4214, 5, 73, 0, 0, 4214, 4215, 5, 19, 0, 0, 4215, 4220, 3, 292, 146, + 0, 4216, 4217, 5, 1140, 0, 0, 4217, 4219, 3, 292, 146, 0, 4218, 4216, 1, + 0, 0, 0, 4219, 4222, 1, 0, 0, 0, 4220, 4218, 1, 0, 0, 0, 4220, 4221, 1, + 0, 0, 0, 4221, 4225, 1, 0, 0, 0, 4222, 4220, 1, 0, 0, 0, 4223, 4224, 5, + 192, 0, 0, 4224, 4226, 5, 599, 0, 0, 4225, 4223, 1, 0, 0, 0, 4225, 4226, + 1, 0, 0, 0, 4226, 287, 1, 0, 0, 0, 4227, 4228, 5, 74, 0, 0, 4228, 4229, + 3, 688, 344, 0, 4229, 289, 1, 0, 0, 0, 4230, 4231, 5, 677, 0, 0, 4231, + 4232, 3, 666, 333, 0, 4232, 4233, 5, 12, 0, 0, 4233, 4234, 5, 1138, 0, + 0, 4234, 4235, 3, 664, 332, 0, 4235, 4245, 5, 1139, 0, 0, 4236, 4237, 5, + 1140, 0, 0, 4237, 4238, 3, 666, 333, 0, 4238, 4239, 5, 12, 0, 0, 4239, + 4240, 5, 1138, 0, 0, 4240, 4241, 3, 664, 332, 0, 4241, 4242, 5, 1139, 0, + 0, 4242, 4244, 1, 0, 0, 0, 4243, 4236, 1, 0, 0, 0, 4244, 4247, 1, 0, 0, + 0, 4245, 4243, 1, 0, 0, 0, 4245, 4246, 1, 0, 0, 0, 4246, 291, 1, 0, 0, + 0, 4247, 4245, 1, 0, 0, 0, 4248, 4250, 3, 688, 344, 0, 4249, 4251, 7, 48, + 0, 0, 4250, 4249, 1, 0, 0, 0, 4250, 4251, 1, 0, 0, 0, 4251, 293, 1, 0, + 0, 0, 4252, 4263, 5, 99, 0, 0, 4253, 4254, 3, 296, 148, 0, 4254, 4255, + 5, 1140, 0, 0, 4255, 4257, 1, 0, 0, 0, 4256, 4253, 1, 0, 0, 0, 4256, 4257, + 1, 0, 0, 0, 4257, 4258, 1, 0, 0, 0, 4258, 4264, 3, 296, 148, 0, 4259, 4260, + 3, 296, 148, 0, 4260, 4261, 5, 533, 0, 0, 4261, 4262, 3, 296, 148, 0, 4262, + 4264, 1, 0, 0, 0, 4263, 4256, 1, 0, 0, 0, 4263, 4259, 1, 0, 0, 0, 4264, + 295, 1, 0, 0, 0, 4265, 4269, 3, 590, 295, 0, 4266, 4269, 3, 566, 283, 0, + 4267, 4269, 3, 586, 293, 0, 4268, 4265, 1, 0, 0, 0, 4268, 4266, 1, 0, 0, + 0, 4268, 4267, 1, 0, 0, 0, 4269, 297, 1, 0, 0, 0, 4270, 4271, 5, 630, 0, + 0, 4271, 4280, 5, 654, 0, 0, 4272, 4277, 3, 320, 160, 0, 4273, 4274, 5, + 1140, 0, 0, 4274, 4276, 3, 320, 160, 0, 4275, 4273, 1, 0, 0, 0, 4276, 4279, + 1, 0, 0, 0, 4277, 4275, 1, 0, 0, 0, 4277, 4278, 1, 0, 0, 0, 4278, 4281, + 1, 0, 0, 0, 4279, 4277, 1, 0, 0, 0, 4280, 4272, 1, 0, 0, 0, 4280, 4281, + 1, 0, 0, 0, 4281, 299, 1, 0, 0, 0, 4282, 4284, 5, 345, 0, 0, 4283, 4285, + 5, 679, 0, 0, 4284, 4283, 1, 0, 0, 0, 4284, 4285, 1, 0, 0, 0, 4285, 301, + 1, 0, 0, 0, 4286, 4288, 5, 370, 0, 0, 4287, 4289, 5, 679, 0, 0, 4288, 4287, + 1, 0, 0, 0, 4288, 4289, 1, 0, 0, 0, 4289, 4295, 1, 0, 0, 0, 4290, 4292, + 5, 10, 0, 0, 4291, 4293, 5, 522, 0, 0, 4292, 4291, 1, 0, 0, 0, 4292, 4293, + 1, 0, 0, 0, 4293, 4294, 1, 0, 0, 0, 4294, 4296, 5, 354, 0, 0, 4295, 4290, + 1, 0, 0, 0, 4295, 4296, 1, 0, 0, 0, 4296, 4301, 1, 0, 0, 0, 4297, 4299, + 5, 522, 0, 0, 4298, 4297, 1, 0, 0, 0, 4298, 4299, 1, 0, 0, 0, 4299, 4300, + 1, 0, 0, 0, 4300, 4302, 5, 138, 0, 0, 4301, 4298, 1, 0, 0, 0, 4301, 4302, + 1, 0, 0, 0, 4302, 303, 1, 0, 0, 0, 4303, 4305, 5, 598, 0, 0, 4304, 4306, + 5, 679, 0, 0, 4305, 4304, 1, 0, 0, 0, 4305, 4306, 1, 0, 0, 0, 4306, 4312, + 1, 0, 0, 0, 4307, 4309, 5, 10, 0, 0, 4308, 4310, 5, 522, 0, 0, 4309, 4308, + 1, 0, 0, 0, 4309, 4310, 1, 0, 0, 0, 4310, 4311, 1, 0, 0, 0, 4311, 4313, + 5, 354, 0, 0, 4312, 4307, 1, 0, 0, 0, 4312, 4313, 1, 0, 0, 0, 4313, 4318, + 1, 0, 0, 0, 4314, 4316, 5, 522, 0, 0, 4315, 4314, 1, 0, 0, 0, 4315, 4316, + 1, 0, 0, 0, 4316, 4317, 1, 0, 0, 0, 4317, 4319, 5, 138, 0, 0, 4318, 4315, + 1, 0, 0, 0, 4318, 4319, 1, 0, 0, 0, 4319, 305, 1, 0, 0, 0, 4320, 4321, + 5, 605, 0, 0, 4321, 4322, 3, 584, 292, 0, 4322, 307, 1, 0, 0, 0, 4323, + 4325, 5, 598, 0, 0, 4324, 4326, 5, 679, 0, 0, 4325, 4324, 1, 0, 0, 0, 4325, + 4326, 1, 0, 0, 0, 4326, 4327, 1, 0, 0, 0, 4327, 4329, 5, 175, 0, 0, 4328, + 4330, 5, 605, 0, 0, 4329, 4328, 1, 0, 0, 0, 4329, 4330, 1, 0, 0, 0, 4330, + 4331, 1, 0, 0, 0, 4331, 4332, 3, 584, 292, 0, 4332, 309, 1, 0, 0, 0, 4333, + 4334, 5, 138, 0, 0, 4334, 4335, 5, 605, 0, 0, 4335, 4336, 3, 584, 292, + 0, 4336, 311, 1, 0, 0, 0, 4337, 4338, 5, 103, 0, 0, 4338, 4339, 7, 54, + 0, 0, 4339, 4344, 3, 322, 161, 0, 4340, 4341, 5, 1140, 0, 0, 4341, 4343, + 3, 322, 161, 0, 4342, 4340, 1, 0, 0, 0, 4343, 4346, 1, 0, 0, 0, 4344, 4342, + 1, 0, 0, 0, 4344, 4345, 1, 0, 0, 0, 4345, 4348, 1, 0, 0, 0, 4346, 4344, + 1, 0, 0, 0, 4347, 4349, 3, 646, 323, 0, 4348, 4347, 1, 0, 0, 0, 4348, 4349, + 1, 0, 0, 0, 4349, 313, 1, 0, 0, 0, 4350, 4351, 5, 182, 0, 0, 4351, 4352, + 5, 743, 0, 0, 4352, 315, 1, 0, 0, 0, 4353, 4354, 5, 153, 0, 0, 4354, 4355, + 5, 341, 0, 0, 4355, 4356, 5, 1129, 0, 0, 4356, 4357, 7, 24, 0, 0, 4357, + 317, 1, 0, 0, 0, 4358, 4360, 5, 153, 0, 0, 4359, 4361, 7, 55, 0, 0, 4360, + 4359, 1, 0, 0, 0, 4360, 4361, 1, 0, 0, 0, 4361, 4362, 1, 0, 0, 0, 4362, + 4363, 5, 654, 0, 0, 4363, 4368, 3, 326, 163, 0, 4364, 4365, 5, 1140, 0, + 0, 4365, 4367, 3, 326, 163, 0, 4366, 4364, 1, 0, 0, 0, 4367, 4370, 1, 0, + 0, 0, 4368, 4366, 1, 0, 0, 0, 4368, 4369, 1, 0, 0, 0, 4369, 319, 1, 0, + 0, 0, 4370, 4368, 1, 0, 0, 0, 4371, 4372, 5, 192, 0, 0, 4372, 4373, 5, + 378, 0, 0, 4373, 4379, 5, 617, 0, 0, 4374, 4375, 5, 134, 0, 0, 4375, 4379, + 5, 193, 0, 0, 4376, 4377, 5, 134, 0, 0, 4377, 4379, 5, 539, 0, 0, 4378, + 4371, 1, 0, 0, 0, 4378, 4374, 1, 0, 0, 0, 4378, 4376, 1, 0, 0, 0, 4379, + 321, 1, 0, 0, 0, 4380, 4385, 3, 552, 276, 0, 4381, 4383, 5, 12, 0, 0, 4382, + 4381, 1, 0, 0, 0, 4382, 4383, 1, 0, 0, 0, 4383, 4384, 1, 0, 0, 0, 4384, + 4386, 3, 584, 292, 0, 4385, 4382, 1, 0, 0, 0, 4385, 4386, 1, 0, 0, 0, 4386, + 4387, 1, 0, 0, 0, 4387, 4388, 3, 324, 162, 0, 4388, 323, 1, 0, 0, 0, 4389, + 4391, 5, 134, 0, 0, 4390, 4392, 5, 475, 0, 0, 4391, 4390, 1, 0, 0, 0, 4391, + 4392, 1, 0, 0, 0, 4392, 4398, 1, 0, 0, 0, 4393, 4395, 5, 106, 0, 0, 4394, + 4393, 1, 0, 0, 0, 4394, 4395, 1, 0, 0, 0, 4395, 4396, 1, 0, 0, 0, 4396, + 4398, 5, 193, 0, 0, 4397, 4389, 1, 0, 0, 0, 4397, 4394, 1, 0, 0, 0, 4398, + 325, 1, 0, 0, 0, 4399, 4400, 5, 465, 0, 0, 4400, 4401, 5, 473, 0, 0, 4401, + 4407, 3, 328, 164, 0, 4402, 4403, 5, 134, 0, 0, 4403, 4407, 5, 193, 0, + 0, 4404, 4405, 5, 134, 0, 0, 4405, 4407, 5, 539, 0, 0, 4406, 4399, 1, 0, + 0, 0, 4406, 4402, 1, 0, 0, 0, 4406, 4404, 1, 0, 0, 0, 4407, 327, 1, 0, + 0, 0, 4408, 4409, 5, 800, 0, 0, 4409, 4416, 5, 134, 0, 0, 4410, 4411, 5, + 134, 0, 0, 4411, 4416, 5, 801, 0, 0, 4412, 4413, 5, 134, 0, 0, 4413, 4416, + 5, 802, 0, 0, 4414, 4416, 5, 803, 0, 0, 4415, 4408, 1, 0, 0, 0, 4415, 4410, + 1, 0, 0, 0, 4415, 4412, 1, 0, 0, 0, 4415, 4414, 1, 0, 0, 0, 4416, 329, + 1, 0, 0, 0, 4417, 4418, 5, 24, 0, 0, 4418, 4419, 5, 478, 0, 0, 4419, 4420, + 5, 175, 0, 0, 4420, 4425, 3, 348, 174, 0, 4421, 4422, 5, 1140, 0, 0, 4422, + 4424, 3, 348, 174, 0, 4423, 4421, 1, 0, 0, 0, 4424, 4427, 1, 0, 0, 0, 4425, + 4423, 1, 0, 0, 0, 4425, 4426, 1, 0, 0, 0, 4426, 4429, 1, 0, 0, 0, 4427, + 4425, 1, 0, 0, 0, 4428, 4430, 3, 356, 178, 0, 4429, 4428, 1, 0, 0, 0, 4429, + 4430, 1, 0, 0, 0, 4430, 331, 1, 0, 0, 0, 4431, 4432, 5, 24, 0, 0, 4432, + 4433, 5, 589, 0, 0, 4433, 4434, 5, 430, 0, 0, 4434, 4439, 3, 358, 179, + 0, 4435, 4436, 5, 1140, 0, 0, 4436, 4438, 3, 358, 179, 0, 4437, 4435, 1, + 0, 0, 0, 4438, 4441, 1, 0, 0, 0, 4439, 4437, 1, 0, 0, 0, 4439, 4440, 1, + 0, 0, 0, 4440, 333, 1, 0, 0, 0, 4441, 4439, 1, 0, 0, 0, 4442, 4443, 5, + 132, 0, 0, 4443, 4444, 7, 56, 0, 0, 4444, 4449, 5, 477, 0, 0, 4445, 4446, + 5, 175, 0, 0, 4446, 4450, 5, 1153, 0, 0, 4447, 4448, 5, 15, 0, 0, 4448, + 4450, 5, 1153, 0, 0, 4449, 4445, 1, 0, 0, 0, 4449, 4447, 1, 0, 0, 0, 4450, + 335, 1, 0, 0, 0, 4451, 4452, 5, 590, 0, 0, 4452, 4453, 5, 478, 0, 0, 4453, + 337, 1, 0, 0, 0, 4454, 4455, 5, 590, 0, 0, 4455, 4457, 5, 615, 0, 0, 4456, + 4458, 5, 6, 0, 0, 4457, 4456, 1, 0, 0, 0, 4457, 4458, 1, 0, 0, 0, 4458, + 4460, 1, 0, 0, 0, 4459, 4461, 3, 356, 178, 0, 4460, 4459, 1, 0, 0, 0, 4460, + 4461, 1, 0, 0, 0, 4461, 339, 1, 0, 0, 0, 4462, 4463, 5, 630, 0, 0, 4463, + 4472, 5, 615, 0, 0, 4464, 4469, 3, 362, 181, 0, 4465, 4466, 5, 1140, 0, + 0, 4466, 4468, 3, 362, 181, 0, 4467, 4465, 1, 0, 0, 0, 4468, 4471, 1, 0, + 0, 0, 4469, 4467, 1, 0, 0, 0, 4469, 4470, 1, 0, 0, 0, 4470, 4473, 1, 0, + 0, 0, 4471, 4469, 1, 0, 0, 0, 4472, 4464, 1, 0, 0, 0, 4472, 4473, 1, 0, + 0, 0, 4473, 4476, 1, 0, 0, 0, 4474, 4475, 5, 664, 0, 0, 4475, 4477, 3, + 364, 182, 0, 4476, 4474, 1, 0, 0, 0, 4476, 4477, 1, 0, 0, 0, 4477, 4481, + 1, 0, 0, 0, 4478, 4480, 3, 366, 183, 0, 4479, 4478, 1, 0, 0, 0, 4480, 4483, + 1, 0, 0, 0, 4481, 4479, 1, 0, 0, 0, 4481, 4482, 1, 0, 0, 0, 4482, 4485, + 1, 0, 0, 0, 4483, 4481, 1, 0, 0, 0, 4484, 4486, 3, 356, 178, 0, 4485, 4484, + 1, 0, 0, 0, 4485, 4486, 1, 0, 0, 0, 4486, 341, 1, 0, 0, 0, 4487, 4488, + 5, 636, 0, 0, 4488, 4497, 5, 615, 0, 0, 4489, 4494, 3, 362, 181, 0, 4490, + 4491, 5, 1140, 0, 0, 4491, 4493, 3, 362, 181, 0, 4492, 4490, 1, 0, 0, 0, + 4493, 4496, 1, 0, 0, 0, 4494, 4492, 1, 0, 0, 0, 4494, 4495, 1, 0, 0, 0, + 4495, 4498, 1, 0, 0, 0, 4496, 4494, 1, 0, 0, 0, 4497, 4489, 1, 0, 0, 0, + 4497, 4498, 1, 0, 0, 0, 4498, 343, 1, 0, 0, 0, 4499, 4500, 5, 630, 0, 0, + 4500, 4501, 5, 442, 0, 0, 4501, 345, 1, 0, 0, 0, 4502, 4503, 5, 636, 0, + 0, 4503, 4504, 5, 442, 0, 0, 4504, 347, 1, 0, 0, 0, 4505, 4506, 3, 350, + 175, 0, 4506, 4507, 5, 1129, 0, 0, 4507, 4508, 5, 1153, 0, 0, 4508, 4535, + 1, 0, 0, 0, 4509, 4510, 3, 352, 176, 0, 4510, 4511, 5, 1129, 0, 0, 4511, + 4512, 3, 590, 295, 0, 4512, 4535, 1, 0, 0, 0, 4513, 4514, 3, 354, 177, + 0, 4514, 4515, 5, 1129, 0, 0, 4515, 4516, 7, 24, 0, 0, 4516, 4535, 1, 0, + 0, 0, 4517, 4518, 5, 482, 0, 0, 4518, 4519, 5, 1129, 0, 0, 4519, 4535, + 5, 1156, 0, 0, 4520, 4521, 5, 450, 0, 0, 4521, 4522, 5, 1129, 0, 0, 4522, + 4531, 5, 1138, 0, 0, 4523, 4528, 3, 584, 292, 0, 4524, 4525, 5, 1140, 0, + 0, 4525, 4527, 3, 584, 292, 0, 4526, 4524, 1, 0, 0, 0, 4527, 4530, 1, 0, + 0, 0, 4528, 4526, 1, 0, 0, 0, 4528, 4529, 1, 0, 0, 0, 4529, 4532, 1, 0, + 0, 0, 4530, 4528, 1, 0, 0, 0, 4531, 4523, 1, 0, 0, 0, 4531, 4532, 1, 0, + 0, 0, 4532, 4533, 1, 0, 0, 0, 4533, 4535, 5, 1139, 0, 0, 4534, 4505, 1, + 0, 0, 0, 4534, 4509, 1, 0, 0, 0, 4534, 4513, 1, 0, 0, 0, 4534, 4517, 1, + 0, 0, 0, 4534, 4520, 1, 0, 0, 0, 4535, 349, 1, 0, 0, 0, 4536, 4537, 7, + 57, 0, 0, 4537, 351, 1, 0, 0, 0, 4538, 4539, 7, 58, 0, 0, 4539, 353, 1, + 0, 0, 0, 4540, 4541, 7, 59, 0, 0, 4541, 355, 1, 0, 0, 0, 4542, 4543, 5, + 65, 0, 0, 4543, 4544, 5, 356, 0, 0, 4544, 4545, 5, 1153, 0, 0, 4545, 357, + 1, 0, 0, 0, 4546, 4547, 5, 582, 0, 0, 4547, 4548, 5, 1129, 0, 0, 4548, + 4549, 5, 1138, 0, 0, 4549, 4550, 3, 616, 308, 0, 4550, 4551, 5, 1139, 0, + 0, 4551, 4596, 1, 0, 0, 0, 4552, 4553, 5, 584, 0, 0, 4553, 4554, 5, 1129, + 0, 0, 4554, 4555, 5, 1138, 0, 0, 4555, 4556, 3, 616, 308, 0, 4556, 4557, + 5, 1139, 0, 0, 4557, 4596, 1, 0, 0, 0, 4558, 4559, 5, 583, 0, 0, 4559, + 4560, 5, 1129, 0, 0, 4560, 4561, 5, 1138, 0, 0, 4561, 4562, 3, 620, 310, + 0, 4562, 4563, 5, 1139, 0, 0, 4563, 4596, 1, 0, 0, 0, 4564, 4565, 5, 585, + 0, 0, 4565, 4566, 5, 1129, 0, 0, 4566, 4567, 5, 1138, 0, 0, 4567, 4568, + 3, 620, 310, 0, 4568, 4569, 5, 1139, 0, 0, 4569, 4596, 1, 0, 0, 0, 4570, + 4571, 5, 587, 0, 0, 4571, 4572, 5, 1129, 0, 0, 4572, 4573, 5, 1138, 0, + 0, 4573, 4574, 3, 630, 315, 0, 4574, 4575, 5, 1139, 0, 0, 4575, 4596, 1, + 0, 0, 0, 4576, 4577, 5, 588, 0, 0, 4577, 4578, 5, 1129, 0, 0, 4578, 4579, + 5, 1138, 0, 0, 4579, 4580, 3, 630, 315, 0, 4580, 4581, 5, 1139, 0, 0, 4581, + 4596, 1, 0, 0, 0, 4582, 4583, 5, 586, 0, 0, 4583, 4584, 5, 1129, 0, 0, + 4584, 4585, 5, 1138, 0, 0, 4585, 4590, 3, 360, 180, 0, 4586, 4587, 5, 1140, + 0, 0, 4587, 4589, 3, 360, 180, 0, 4588, 4586, 1, 0, 0, 0, 4589, 4592, 1, + 0, 0, 0, 4590, 4588, 1, 0, 0, 0, 4590, 4591, 1, 0, 0, 0, 4591, 4593, 1, + 0, 0, 0, 4592, 4590, 1, 0, 0, 0, 4593, 4594, 5, 1139, 0, 0, 4594, 4596, + 1, 0, 0, 0, 4595, 4546, 1, 0, 0, 0, 4595, 4552, 1, 0, 0, 0, 4595, 4558, + 1, 0, 0, 0, 4595, 4564, 1, 0, 0, 0, 4595, 4570, 1, 0, 0, 0, 4595, 4576, + 1, 0, 0, 0, 4595, 4582, 1, 0, 0, 0, 4596, 359, 1, 0, 0, 0, 4597, 4598, + 5, 1138, 0, 0, 4598, 4599, 3, 552, 276, 0, 4599, 4600, 5, 1140, 0, 0, 4600, + 4601, 3, 552, 276, 0, 4601, 4602, 5, 1139, 0, 0, 4602, 361, 1, 0, 0, 0, + 4603, 4604, 7, 60, 0, 0, 4604, 363, 1, 0, 0, 0, 4605, 4606, 7, 61, 0, 0, + 4606, 4607, 5, 1129, 0, 0, 4607, 4624, 3, 368, 184, 0, 4608, 4609, 5, 484, + 0, 0, 4609, 4610, 5, 1129, 0, 0, 4610, 4611, 5, 1153, 0, 0, 4611, 4612, + 5, 1140, 0, 0, 4612, 4613, 5, 485, 0, 0, 4613, 4614, 5, 1129, 0, 0, 4614, + 4624, 3, 590, 295, 0, 4615, 4616, 5, 576, 0, 0, 4616, 4617, 5, 1129, 0, + 0, 4617, 4618, 5, 1153, 0, 0, 4618, 4619, 5, 1140, 0, 0, 4619, 4620, 5, + 577, 0, 0, 4620, 4621, 5, 1129, 0, 0, 4621, 4624, 3, 590, 295, 0, 4622, + 4624, 5, 624, 0, 0, 4623, 4605, 1, 0, 0, 0, 4623, 4608, 1, 0, 0, 0, 4623, + 4615, 1, 0, 0, 0, 4623, 4622, 1, 0, 0, 0, 4624, 365, 1, 0, 0, 0, 4625, + 4626, 5, 666, 0, 0, 4626, 4627, 5, 1129, 0, 0, 4627, 4638, 5, 1153, 0, + 0, 4628, 4629, 5, 552, 0, 0, 4629, 4630, 5, 1129, 0, 0, 4630, 4638, 5, + 1153, 0, 0, 4631, 4632, 5, 392, 0, 0, 4632, 4633, 5, 1129, 0, 0, 4633, + 4638, 5, 1153, 0, 0, 4634, 4635, 5, 556, 0, 0, 4635, 4636, 5, 1129, 0, + 0, 4636, 4638, 5, 1153, 0, 0, 4637, 4625, 1, 0, 0, 0, 4637, 4628, 1, 0, + 0, 0, 4637, 4631, 1, 0, 0, 0, 4637, 4634, 1, 0, 0, 0, 4638, 367, 1, 0, + 0, 0, 4639, 4644, 3, 576, 288, 0, 4640, 4641, 5, 1140, 0, 0, 4641, 4643, + 3, 576, 288, 0, 4642, 4640, 1, 0, 0, 0, 4643, 4646, 1, 0, 0, 0, 4644, 4642, + 1, 0, 0, 0, 4644, 4645, 1, 0, 0, 0, 4645, 4649, 1, 0, 0, 0, 4646, 4644, + 1, 0, 0, 0, 4647, 4649, 5, 1153, 0, 0, 4648, 4639, 1, 0, 0, 0, 4648, 4647, + 1, 0, 0, 0, 4649, 369, 1, 0, 0, 0, 4650, 4651, 5, 682, 0, 0, 4651, 4652, + 7, 62, 0, 0, 4652, 4654, 3, 578, 289, 0, 4653, 4655, 7, 63, 0, 0, 4654, + 4653, 1, 0, 0, 0, 4654, 4655, 1, 0, 0, 0, 4655, 371, 1, 0, 0, 0, 4656, + 4657, 5, 682, 0, 0, 4657, 4658, 5, 408, 0, 0, 4658, 4664, 3, 578, 289, + 0, 4659, 4662, 5, 644, 0, 0, 4660, 4661, 5, 65, 0, 0, 4661, 4663, 5, 510, + 0, 0, 4662, 4660, 1, 0, 0, 0, 4662, 4663, 1, 0, 0, 0, 4663, 4665, 1, 0, + 0, 0, 4664, 4659, 1, 0, 0, 0, 4664, 4665, 1, 0, 0, 0, 4665, 373, 1, 0, + 0, 0, 4666, 4667, 5, 682, 0, 0, 4667, 4668, 5, 561, 0, 0, 4668, 4669, 3, + 578, 289, 0, 4669, 375, 1, 0, 0, 0, 4670, 4671, 5, 682, 0, 0, 4671, 4672, + 5, 370, 0, 0, 4672, 4675, 3, 578, 289, 0, 4673, 4674, 5, 537, 0, 0, 4674, + 4676, 5, 554, 0, 0, 4675, 4673, 1, 0, 0, 0, 4675, 4676, 1, 0, 0, 0, 4676, + 377, 1, 0, 0, 0, 4677, 4678, 5, 682, 0, 0, 4678, 4679, 5, 598, 0, 0, 4679, + 4680, 3, 578, 289, 0, 4680, 379, 1, 0, 0, 0, 4681, 4682, 5, 682, 0, 0, + 4682, 4685, 5, 571, 0, 0, 4683, 4684, 5, 32, 0, 0, 4684, 4686, 3, 578, + 289, 0, 4685, 4683, 1, 0, 0, 0, 4685, 4686, 1, 0, 0, 0, 4686, 381, 1, 0, + 0, 0, 4687, 4688, 5, 561, 0, 0, 4688, 4689, 3, 584, 292, 0, 4689, 4692, + 5, 68, 0, 0, 4690, 4693, 5, 1153, 0, 0, 4691, 4693, 5, 1164, 0, 0, 4692, + 4690, 1, 0, 0, 0, 4692, 4691, 1, 0, 0, 0, 4693, 383, 1, 0, 0, 0, 4694, + 4695, 5, 709, 0, 0, 4695, 4698, 3, 584, 292, 0, 4696, 4697, 5, 187, 0, + 0, 4697, 4699, 3, 632, 316, 0, 4698, 4696, 1, 0, 0, 0, 4698, 4699, 1, 0, + 0, 0, 4699, 385, 1, 0, 0, 0, 4700, 4701, 7, 64, 0, 0, 4701, 4702, 5, 561, + 0, 0, 4702, 4703, 3, 584, 292, 0, 4703, 387, 1, 0, 0, 0, 4704, 4707, 3, + 390, 195, 0, 4705, 4707, 3, 4, 2, 0, 4706, 4704, 1, 0, 0, 0, 4706, 4705, + 1, 0, 0, 0, 4707, 389, 1, 0, 0, 0, 4708, 4709, 3, 584, 292, 0, 4709, 4710, + 5, 1149, 0, 0, 4710, 4712, 1, 0, 0, 0, 4711, 4708, 1, 0, 0, 0, 4711, 4712, + 1, 0, 0, 0, 4712, 4713, 1, 0, 0, 0, 4713, 4719, 5, 345, 0, 0, 4714, 4715, + 3, 410, 205, 0, 4715, 4716, 5, 1141, 0, 0, 4716, 4718, 1, 0, 0, 0, 4717, + 4714, 1, 0, 0, 0, 4718, 4721, 1, 0, 0, 0, 4719, 4717, 1, 0, 0, 0, 4719, + 4720, 1, 0, 0, 0, 4720, 4727, 1, 0, 0, 0, 4721, 4719, 1, 0, 0, 0, 4722, + 4723, 3, 412, 206, 0, 4723, 4724, 5, 1141, 0, 0, 4724, 4726, 1, 0, 0, 0, + 4725, 4722, 1, 0, 0, 0, 4726, 4729, 1, 0, 0, 0, 4727, 4725, 1, 0, 0, 0, + 4727, 4728, 1, 0, 0, 0, 4728, 4735, 1, 0, 0, 0, 4729, 4727, 1, 0, 0, 0, + 4730, 4731, 3, 414, 207, 0, 4731, 4732, 5, 1141, 0, 0, 4732, 4734, 1, 0, + 0, 0, 4733, 4730, 1, 0, 0, 0, 4734, 4737, 1, 0, 0, 0, 4735, 4733, 1, 0, + 0, 0, 4735, 4736, 1, 0, 0, 0, 4736, 4743, 1, 0, 0, 0, 4737, 4735, 1, 0, + 0, 0, 4738, 4739, 3, 416, 208, 0, 4739, 4740, 5, 1141, 0, 0, 4740, 4742, + 1, 0, 0, 0, 4741, 4738, 1, 0, 0, 0, 4742, 4745, 1, 0, 0, 0, 4743, 4741, + 1, 0, 0, 0, 4743, 4744, 1, 0, 0, 0, 4744, 4749, 1, 0, 0, 0, 4745, 4743, + 1, 0, 0, 0, 4746, 4748, 3, 420, 210, 0, 4747, 4746, 1, 0, 0, 0, 4748, 4751, + 1, 0, 0, 0, 4749, 4747, 1, 0, 0, 0, 4749, 4750, 1, 0, 0, 0, 4750, 4752, + 1, 0, 0, 0, 4751, 4749, 1, 0, 0, 0, 4752, 4754, 5, 408, 0, 0, 4753, 4755, + 3, 584, 292, 0, 4754, 4753, 1, 0, 0, 0, 4754, 4755, 1, 0, 0, 0, 4755, 391, + 1, 0, 0, 0, 4756, 4759, 5, 22, 0, 0, 4757, 4760, 3, 584, 292, 0, 4758, + 4760, 3, 688, 344, 0, 4759, 4757, 1, 0, 0, 0, 4759, 4758, 1, 0, 0, 0, 4759, + 4760, 1, 0, 0, 0, 4760, 4762, 1, 0, 0, 0, 4761, 4763, 3, 422, 211, 0, 4762, + 4761, 1, 0, 0, 0, 4763, 4764, 1, 0, 0, 0, 4764, 4762, 1, 0, 0, 0, 4764, + 4765, 1, 0, 0, 0, 4765, 4772, 1, 0, 0, 0, 4766, 4768, 5, 53, 0, 0, 4767, + 4769, 3, 420, 210, 0, 4768, 4767, 1, 0, 0, 0, 4769, 4770, 1, 0, 0, 0, 4770, + 4768, 1, 0, 0, 0, 4770, 4771, 1, 0, 0, 0, 4771, 4773, 1, 0, 0, 0, 4772, + 4766, 1, 0, 0, 0, 4772, 4773, 1, 0, 0, 0, 4773, 4774, 1, 0, 0, 0, 4774, + 4775, 5, 408, 0, 0, 4775, 4776, 5, 22, 0, 0, 4776, 393, 1, 0, 0, 0, 4777, + 4778, 5, 77, 0, 0, 4778, 4779, 3, 688, 344, 0, 4779, 4781, 5, 174, 0, 0, + 4780, 4782, 3, 420, 210, 0, 4781, 4780, 1, 0, 0, 0, 4782, 4783, 1, 0, 0, + 0, 4783, 4781, 1, 0, 0, 0, 4783, 4784, 1, 0, 0, 0, 4784, 4788, 1, 0, 0, + 0, 4785, 4787, 3, 424, 212, 0, 4786, 4785, 1, 0, 0, 0, 4787, 4790, 1, 0, + 0, 0, 4788, 4786, 1, 0, 0, 0, 4788, 4789, 1, 0, 0, 0, 4789, 4797, 1, 0, + 0, 0, 4790, 4788, 1, 0, 0, 0, 4791, 4793, 5, 53, 0, 0, 4792, 4794, 3, 420, + 210, 0, 4793, 4792, 1, 0, 0, 0, 4794, 4795, 1, 0, 0, 0, 4795, 4793, 1, + 0, 0, 0, 4795, 4796, 1, 0, 0, 0, 4796, 4798, 1, 0, 0, 0, 4797, 4791, 1, + 0, 0, 0, 4797, 4798, 1, 0, 0, 0, 4798, 4799, 1, 0, 0, 0, 4799, 4800, 5, + 408, 0, 0, 4800, 4801, 5, 77, 0, 0, 4801, 395, 1, 0, 0, 0, 4802, 4803, + 5, 89, 0, 0, 4803, 4804, 3, 584, 292, 0, 4804, 397, 1, 0, 0, 0, 4805, 4806, + 5, 96, 0, 0, 4806, 4807, 3, 584, 292, 0, 4807, 399, 1, 0, 0, 0, 4808, 4809, + 3, 584, 292, 0, 4809, 4810, 5, 1149, 0, 0, 4810, 4812, 1, 0, 0, 0, 4811, + 4808, 1, 0, 0, 0, 4811, 4812, 1, 0, 0, 0, 4812, 4813, 1, 0, 0, 0, 4813, + 4815, 5, 105, 0, 0, 4814, 4816, 3, 420, 210, 0, 4815, 4814, 1, 0, 0, 0, + 4816, 4817, 1, 0, 0, 0, 4817, 4815, 1, 0, 0, 0, 4817, 4818, 1, 0, 0, 0, + 4818, 4819, 1, 0, 0, 0, 4819, 4820, 5, 408, 0, 0, 4820, 4822, 5, 105, 0, + 0, 4821, 4823, 3, 584, 292, 0, 4822, 4821, 1, 0, 0, 0, 4822, 4823, 1, 0, + 0, 0, 4823, 401, 1, 0, 0, 0, 4824, 4825, 3, 584, 292, 0, 4825, 4826, 5, + 1149, 0, 0, 4826, 4828, 1, 0, 0, 0, 4827, 4824, 1, 0, 0, 0, 4827, 4828, + 1, 0, 0, 0, 4828, 4829, 1, 0, 0, 0, 4829, 4831, 5, 140, 0, 0, 4830, 4832, + 3, 420, 210, 0, 4831, 4830, 1, 0, 0, 0, 4832, 4833, 1, 0, 0, 0, 4833, 4831, + 1, 0, 0, 0, 4833, 4834, 1, 0, 0, 0, 4834, 4835, 1, 0, 0, 0, 4835, 4836, + 5, 664, 0, 0, 4836, 4837, 3, 688, 344, 0, 4837, 4838, 5, 408, 0, 0, 4838, + 4840, 5, 140, 0, 0, 4839, 4841, 3, 584, 292, 0, 4840, 4839, 1, 0, 0, 0, + 4840, 4841, 1, 0, 0, 0, 4841, 403, 1, 0, 0, 0, 4842, 4843, 5, 146, 0, 0, + 4843, 4844, 3, 688, 344, 0, 4844, 405, 1, 0, 0, 0, 4845, 4846, 3, 584, + 292, 0, 4846, 4847, 5, 1149, 0, 0, 4847, 4849, 1, 0, 0, 0, 4848, 4845, + 1, 0, 0, 0, 4848, 4849, 1, 0, 0, 0, 4849, 4850, 1, 0, 0, 0, 4850, 4851, + 5, 191, 0, 0, 4851, 4852, 3, 688, 344, 0, 4852, 4854, 5, 400, 0, 0, 4853, + 4855, 3, 420, 210, 0, 4854, 4853, 1, 0, 0, 0, 4855, 4856, 1, 0, 0, 0, 4856, + 4854, 1, 0, 0, 0, 4856, 4857, 1, 0, 0, 0, 4857, 4858, 1, 0, 0, 0, 4858, + 4859, 5, 408, 0, 0, 4859, 4861, 5, 191, 0, 0, 4860, 4862, 3, 584, 292, + 0, 4861, 4860, 1, 0, 0, 0, 4861, 4862, 1, 0, 0, 0, 4862, 407, 1, 0, 0, + 0, 4863, 4864, 5, 362, 0, 0, 4864, 4879, 3, 584, 292, 0, 4865, 4870, 5, + 64, 0, 0, 4866, 4868, 5, 521, 0, 0, 4867, 4866, 1, 0, 0, 0, 4867, 4868, + 1, 0, 0, 0, 4868, 4869, 1, 0, 0, 0, 4869, 4871, 5, 68, 0, 0, 4870, 4867, + 1, 0, 0, 0, 4870, 4871, 1, 0, 0, 0, 4871, 4872, 1, 0, 0, 0, 4872, 4873, + 3, 584, 292, 0, 4873, 4874, 5, 87, 0, 0, 4874, 4875, 3, 616, 308, 0, 4875, + 4879, 1, 0, 0, 0, 4876, 4877, 5, 540, 0, 0, 4877, 4879, 3, 584, 292, 0, + 4878, 4863, 1, 0, 0, 0, 4878, 4865, 1, 0, 0, 0, 4878, 4876, 1, 0, 0, 0, + 4879, 409, 1, 0, 0, 0, 4880, 4881, 5, 41, 0, 0, 4881, 4882, 3, 616, 308, + 0, 4882, 4885, 3, 604, 302, 0, 4883, 4884, 5, 42, 0, 0, 4884, 4886, 3, + 688, 344, 0, 4885, 4883, 1, 0, 0, 0, 4885, 4886, 1, 0, 0, 0, 4886, 411, + 1, 0, 0, 0, 4887, 4888, 5, 41, 0, 0, 4888, 4889, 3, 584, 292, 0, 4889, + 4890, 5, 29, 0, 0, 4890, 4897, 5, 65, 0, 0, 4891, 4898, 3, 590, 295, 0, + 4892, 4894, 5, 162, 0, 0, 4893, 4895, 5, 670, 0, 0, 4894, 4893, 1, 0, 0, + 0, 4894, 4895, 1, 0, 0, 0, 4895, 4896, 1, 0, 0, 0, 4896, 4898, 5, 1153, + 0, 0, 4897, 4891, 1, 0, 0, 0, 4897, 4892, 1, 0, 0, 0, 4898, 413, 1, 0, + 0, 0, 4899, 4900, 5, 41, 0, 0, 4900, 4901, 3, 584, 292, 0, 4901, 4902, + 5, 38, 0, 0, 4902, 4903, 5, 65, 0, 0, 4903, 4904, 3, 200, 100, 0, 4904, + 415, 1, 0, 0, 0, 4905, 4906, 5, 41, 0, 0, 4906, 4907, 7, 65, 0, 0, 4907, + 4908, 5, 443, 0, 0, 4908, 4909, 5, 65, 0, 0, 4909, 4914, 3, 418, 209, 0, + 4910, 4911, 5, 1140, 0, 0, 4911, 4913, 3, 418, 209, 0, 4912, 4910, 1, 0, + 0, 0, 4913, 4916, 1, 0, 0, 0, 4914, 4912, 1, 0, 0, 0, 4914, 4915, 1, 0, + 0, 0, 4915, 4917, 1, 0, 0, 0, 4916, 4914, 1, 0, 0, 0, 4917, 4918, 3, 388, + 194, 0, 4918, 417, 1, 0, 0, 0, 4919, 4931, 3, 590, 295, 0, 4920, 4922, + 5, 162, 0, 0, 4921, 4923, 5, 670, 0, 0, 4922, 4921, 1, 0, 0, 0, 4922, 4923, + 1, 0, 0, 0, 4923, 4924, 1, 0, 0, 0, 4924, 4931, 5, 1153, 0, 0, 4925, 4931, + 3, 584, 292, 0, 4926, 4931, 5, 163, 0, 0, 4927, 4928, 5, 114, 0, 0, 4928, + 4931, 5, 436, 0, 0, 4929, 4931, 5, 161, 0, 0, 4930, 4919, 1, 0, 0, 0, 4930, + 4920, 1, 0, 0, 0, 4930, 4925, 1, 0, 0, 0, 4930, 4926, 1, 0, 0, 0, 4930, + 4927, 1, 0, 0, 0, 4930, 4929, 1, 0, 0, 0, 4931, 419, 1, 0, 0, 0, 4932, + 4935, 3, 18, 9, 0, 4933, 4935, 3, 4, 2, 0, 4934, 4932, 1, 0, 0, 0, 4934, + 4933, 1, 0, 0, 0, 4935, 4936, 1, 0, 0, 0, 4936, 4937, 5, 1141, 0, 0, 4937, + 421, 1, 0, 0, 0, 4938, 4941, 5, 189, 0, 0, 4939, 4942, 3, 602, 301, 0, + 4940, 4942, 3, 688, 344, 0, 4941, 4939, 1, 0, 0, 0, 4941, 4940, 1, 0, 0, + 0, 4942, 4943, 1, 0, 0, 0, 4943, 4945, 5, 174, 0, 0, 4944, 4946, 3, 420, + 210, 0, 4945, 4944, 1, 0, 0, 0, 4946, 4947, 1, 0, 0, 0, 4947, 4945, 1, + 0, 0, 0, 4947, 4948, 1, 0, 0, 0, 4948, 423, 1, 0, 0, 0, 4949, 4950, 5, + 54, 0, 0, 4950, 4951, 3, 688, 344, 0, 4951, 4953, 5, 174, 0, 0, 4952, 4954, + 3, 420, 210, 0, 4953, 4952, 1, 0, 0, 0, 4954, 4955, 1, 0, 0, 0, 4955, 4953, + 1, 0, 0, 0, 4955, 4956, 1, 0, 0, 0, 4956, 425, 1, 0, 0, 0, 4957, 4958, + 5, 7, 0, 0, 4958, 4959, 5, 666, 0, 0, 4959, 4964, 3, 446, 223, 0, 4960, + 4961, 5, 1140, 0, 0, 4961, 4963, 3, 446, 223, 0, 4962, 4960, 1, 0, 0, 0, + 4963, 4966, 1, 0, 0, 0, 4964, 4962, 1, 0, 0, 0, 4964, 4965, 1, 0, 0, 0, + 4965, 5031, 1, 0, 0, 0, 4966, 4964, 1, 0, 0, 0, 4967, 4968, 5, 7, 0, 0, + 4968, 4970, 5, 666, 0, 0, 4969, 4971, 3, 640, 320, 0, 4970, 4969, 1, 0, + 0, 0, 4970, 4971, 1, 0, 0, 0, 4971, 4972, 1, 0, 0, 0, 4972, 4977, 3, 448, + 224, 0, 4973, 4974, 5, 1140, 0, 0, 4974, 4976, 3, 448, 224, 0, 4975, 4973, + 1, 0, 0, 0, 4976, 4979, 1, 0, 0, 0, 4977, 4975, 1, 0, 0, 0, 4977, 4978, + 1, 0, 0, 0, 4978, 4994, 1, 0, 0, 0, 4979, 4977, 1, 0, 0, 0, 4980, 4992, + 5, 142, 0, 0, 4981, 4993, 5, 530, 0, 0, 4982, 4989, 3, 454, 227, 0, 4983, + 4985, 5, 10, 0, 0, 4984, 4983, 1, 0, 0, 0, 4984, 4985, 1, 0, 0, 0, 4985, + 4986, 1, 0, 0, 0, 4986, 4988, 3, 454, 227, 0, 4987, 4984, 1, 0, 0, 0, 4988, + 4991, 1, 0, 0, 0, 4989, 4987, 1, 0, 0, 0, 4989, 4990, 1, 0, 0, 0, 4990, + 4993, 1, 0, 0, 0, 4991, 4989, 1, 0, 0, 0, 4992, 4981, 1, 0, 0, 0, 4992, + 4982, 1, 0, 0, 0, 4993, 4995, 1, 0, 0, 0, 4994, 4980, 1, 0, 0, 0, 4994, + 4995, 1, 0, 0, 0, 4995, 5002, 1, 0, 0, 0, 4996, 4998, 5, 192, 0, 0, 4997, + 4999, 3, 456, 228, 0, 4998, 4997, 1, 0, 0, 0, 4999, 5000, 1, 0, 0, 0, 5000, + 4998, 1, 0, 0, 0, 5000, 5001, 1, 0, 0, 0, 5001, 5003, 1, 0, 0, 0, 5002, + 4996, 1, 0, 0, 0, 5002, 5003, 1, 0, 0, 0, 5003, 5008, 1, 0, 0, 0, 5004, + 5007, 3, 458, 229, 0, 5005, 5007, 3, 460, 230, 0, 5006, 5004, 1, 0, 0, + 0, 5006, 5005, 1, 0, 0, 0, 5007, 5010, 1, 0, 0, 0, 5008, 5006, 1, 0, 0, + 0, 5008, 5009, 1, 0, 0, 0, 5009, 5015, 1, 0, 0, 0, 5010, 5008, 1, 0, 0, + 0, 5011, 5012, 5, 369, 0, 0, 5012, 5016, 5, 1153, 0, 0, 5013, 5014, 5, + 14, 0, 0, 5014, 5016, 5, 1153, 0, 0, 5015, 5011, 1, 0, 0, 0, 5015, 5013, + 1, 0, 0, 0, 5015, 5016, 1, 0, 0, 0, 5016, 5031, 1, 0, 0, 0, 5017, 5018, + 5, 7, 0, 0, 5018, 5020, 5, 666, 0, 0, 5019, 5021, 3, 640, 320, 0, 5020, + 5019, 1, 0, 0, 0, 5020, 5021, 1, 0, 0, 0, 5021, 5024, 1, 0, 0, 0, 5022, + 5025, 3, 564, 282, 0, 5023, 5025, 3, 584, 292, 0, 5024, 5022, 1, 0, 0, + 0, 5024, 5023, 1, 0, 0, 0, 5025, 5026, 1, 0, 0, 0, 5026, 5027, 5, 42, 0, + 0, 5027, 5028, 5, 597, 0, 0, 5028, 5029, 3, 434, 217, 0, 5029, 5031, 1, + 0, 0, 0, 5030, 4957, 1, 0, 0, 0, 5030, 4967, 1, 0, 0, 0, 5030, 5017, 1, + 0, 0, 0, 5031, 427, 1, 0, 0, 0, 5032, 5033, 5, 33, 0, 0, 5033, 5034, 5, + 666, 0, 0, 5034, 5039, 3, 448, 224, 0, 5035, 5036, 5, 1140, 0, 0, 5036, + 5038, 3, 448, 224, 0, 5037, 5035, 1, 0, 0, 0, 5038, 5041, 1, 0, 0, 0, 5039, + 5037, 1, 0, 0, 0, 5039, 5040, 1, 0, 0, 0, 5040, 5098, 1, 0, 0, 0, 5041, + 5039, 1, 0, 0, 0, 5042, 5043, 5, 33, 0, 0, 5043, 5045, 5, 666, 0, 0, 5044, + 5046, 3, 642, 321, 0, 5045, 5044, 1, 0, 0, 0, 5045, 5046, 1, 0, 0, 0, 5046, + 5047, 1, 0, 0, 0, 5047, 5052, 3, 448, 224, 0, 5048, 5049, 5, 1140, 0, 0, + 5049, 5051, 3, 448, 224, 0, 5050, 5048, 1, 0, 0, 0, 5051, 5054, 1, 0, 0, + 0, 5052, 5050, 1, 0, 0, 0, 5052, 5053, 1, 0, 0, 0, 5053, 5058, 1, 0, 0, + 0, 5054, 5052, 1, 0, 0, 0, 5055, 5056, 5, 42, 0, 0, 5056, 5057, 5, 597, + 0, 0, 5057, 5059, 3, 434, 217, 0, 5058, 5055, 1, 0, 0, 0, 5058, 5059, 1, + 0, 0, 0, 5059, 5074, 1, 0, 0, 0, 5060, 5072, 5, 142, 0, 0, 5061, 5073, + 5, 530, 0, 0, 5062, 5069, 3, 454, 227, 0, 5063, 5065, 5, 10, 0, 0, 5064, + 5063, 1, 0, 0, 0, 5064, 5065, 1, 0, 0, 0, 5065, 5066, 1, 0, 0, 0, 5066, + 5068, 3, 454, 227, 0, 5067, 5064, 1, 0, 0, 0, 5068, 5071, 1, 0, 0, 0, 5069, + 5067, 1, 0, 0, 0, 5069, 5070, 1, 0, 0, 0, 5070, 5073, 1, 0, 0, 0, 5071, + 5069, 1, 0, 0, 0, 5072, 5061, 1, 0, 0, 0, 5072, 5062, 1, 0, 0, 0, 5073, + 5075, 1, 0, 0, 0, 5074, 5060, 1, 0, 0, 0, 5074, 5075, 1, 0, 0, 0, 5075, + 5082, 1, 0, 0, 0, 5076, 5078, 5, 192, 0, 0, 5077, 5079, 3, 456, 228, 0, + 5078, 5077, 1, 0, 0, 0, 5079, 5080, 1, 0, 0, 0, 5080, 5078, 1, 0, 0, 0, + 5080, 5081, 1, 0, 0, 0, 5081, 5083, 1, 0, 0, 0, 5082, 5076, 1, 0, 0, 0, + 5082, 5083, 1, 0, 0, 0, 5083, 5088, 1, 0, 0, 0, 5084, 5087, 3, 458, 229, + 0, 5085, 5087, 3, 460, 230, 0, 5086, 5084, 1, 0, 0, 0, 5086, 5085, 1, 0, + 0, 0, 5087, 5090, 1, 0, 0, 0, 5088, 5086, 1, 0, 0, 0, 5088, 5089, 1, 0, + 0, 0, 5089, 5095, 1, 0, 0, 0, 5090, 5088, 1, 0, 0, 0, 5091, 5092, 5, 369, + 0, 0, 5092, 5096, 5, 1153, 0, 0, 5093, 5094, 5, 14, 0, 0, 5094, 5096, 5, + 1153, 0, 0, 5095, 5091, 1, 0, 0, 0, 5095, 5093, 1, 0, 0, 0, 5095, 5096, + 1, 0, 0, 0, 5096, 5098, 1, 0, 0, 0, 5097, 5032, 1, 0, 0, 0, 5097, 5042, + 1, 0, 0, 0, 5098, 429, 1, 0, 0, 0, 5099, 5100, 5, 51, 0, 0, 5100, 5102, + 5, 666, 0, 0, 5101, 5103, 3, 640, 320, 0, 5102, 5101, 1, 0, 0, 0, 5102, + 5103, 1, 0, 0, 0, 5103, 5104, 1, 0, 0, 0, 5104, 5109, 3, 564, 282, 0, 5105, + 5106, 5, 1140, 0, 0, 5106, 5108, 3, 564, 282, 0, 5107, 5105, 1, 0, 0, 0, + 5108, 5111, 1, 0, 0, 0, 5109, 5107, 1, 0, 0, 0, 5109, 5110, 1, 0, 0, 0, + 5110, 431, 1, 0, 0, 0, 5111, 5109, 1, 0, 0, 0, 5112, 5113, 5, 72, 0, 0, + 5113, 5118, 3, 462, 231, 0, 5114, 5115, 5, 1140, 0, 0, 5115, 5117, 3, 462, + 231, 0, 5116, 5114, 1, 0, 0, 0, 5117, 5120, 1, 0, 0, 0, 5118, 5116, 1, + 0, 0, 0, 5118, 5119, 1, 0, 0, 0, 5119, 5121, 1, 0, 0, 0, 5120, 5118, 1, + 0, 0, 0, 5121, 5123, 5, 118, 0, 0, 5122, 5124, 7, 66, 0, 0, 5123, 5122, + 1, 0, 0, 0, 5123, 5124, 1, 0, 0, 0, 5124, 5125, 1, 0, 0, 0, 5125, 5126, + 3, 466, 233, 0, 5126, 5127, 5, 175, 0, 0, 5127, 5132, 3, 448, 224, 0, 5128, + 5129, 5, 1140, 0, 0, 5129, 5131, 3, 448, 224, 0, 5130, 5128, 1, 0, 0, 0, + 5131, 5134, 1, 0, 0, 0, 5132, 5130, 1, 0, 0, 0, 5132, 5133, 1, 0, 0, 0, + 5133, 5149, 1, 0, 0, 0, 5134, 5132, 1, 0, 0, 0, 5135, 5147, 5, 142, 0, + 0, 5136, 5148, 5, 530, 0, 0, 5137, 5144, 3, 454, 227, 0, 5138, 5140, 5, + 10, 0, 0, 5139, 5138, 1, 0, 0, 0, 5139, 5140, 1, 0, 0, 0, 5140, 5141, 1, + 0, 0, 0, 5141, 5143, 3, 454, 227, 0, 5142, 5139, 1, 0, 0, 0, 5143, 5146, + 1, 0, 0, 0, 5144, 5142, 1, 0, 0, 0, 5144, 5145, 1, 0, 0, 0, 5145, 5148, + 1, 0, 0, 0, 5146, 5144, 1, 0, 0, 0, 5147, 5136, 1, 0, 0, 0, 5147, 5137, + 1, 0, 0, 0, 5148, 5150, 1, 0, 0, 0, 5149, 5135, 1, 0, 0, 0, 5149, 5150, + 1, 0, 0, 0, 5150, 5160, 1, 0, 0, 0, 5151, 5157, 5, 192, 0, 0, 5152, 5153, + 5, 72, 0, 0, 5153, 5156, 5, 120, 0, 0, 5154, 5156, 3, 456, 228, 0, 5155, + 5152, 1, 0, 0, 0, 5155, 5154, 1, 0, 0, 0, 5156, 5159, 1, 0, 0, 0, 5157, + 5155, 1, 0, 0, 0, 5157, 5158, 1, 0, 0, 0, 5158, 5161, 1, 0, 0, 0, 5159, + 5157, 1, 0, 0, 0, 5160, 5151, 1, 0, 0, 0, 5160, 5161, 1, 0, 0, 0, 5161, + 5168, 1, 0, 0, 0, 5162, 5163, 5, 12, 0, 0, 5163, 5164, 3, 564, 282, 0, + 5164, 5165, 5, 192, 0, 0, 5165, 5166, 5, 597, 0, 0, 5166, 5167, 3, 434, + 217, 0, 5167, 5169, 1, 0, 0, 0, 5168, 5162, 1, 0, 0, 0, 5168, 5169, 1, + 0, 0, 0, 5169, 5206, 1, 0, 0, 0, 5170, 5173, 5, 72, 0, 0, 5171, 5174, 3, + 564, 282, 0, 5172, 5174, 3, 584, 292, 0, 5173, 5171, 1, 0, 0, 0, 5173, + 5172, 1, 0, 0, 0, 5174, 5182, 1, 0, 0, 0, 5175, 5178, 5, 1140, 0, 0, 5176, + 5179, 3, 564, 282, 0, 5177, 5179, 3, 584, 292, 0, 5178, 5176, 1, 0, 0, + 0, 5178, 5177, 1, 0, 0, 0, 5179, 5181, 1, 0, 0, 0, 5180, 5175, 1, 0, 0, + 0, 5181, 5184, 1, 0, 0, 0, 5182, 5180, 1, 0, 0, 0, 5182, 5183, 1, 0, 0, + 0, 5183, 5185, 1, 0, 0, 0, 5184, 5182, 1, 0, 0, 0, 5185, 5188, 5, 175, + 0, 0, 5186, 5189, 3, 564, 282, 0, 5187, 5189, 3, 584, 292, 0, 5188, 5186, + 1, 0, 0, 0, 5188, 5187, 1, 0, 0, 0, 5189, 5197, 1, 0, 0, 0, 5190, 5193, + 5, 1140, 0, 0, 5191, 5194, 3, 564, 282, 0, 5192, 5194, 3, 584, 292, 0, + 5193, 5191, 1, 0, 0, 0, 5193, 5192, 1, 0, 0, 0, 5194, 5196, 1, 0, 0, 0, + 5195, 5190, 1, 0, 0, 0, 5196, 5199, 1, 0, 0, 0, 5197, 5195, 1, 0, 0, 0, + 5197, 5198, 1, 0, 0, 0, 5198, 5203, 1, 0, 0, 0, 5199, 5197, 1, 0, 0, 0, + 5200, 5201, 5, 192, 0, 0, 5201, 5202, 5, 698, 0, 0, 5202, 5204, 5, 120, + 0, 0, 5203, 5200, 1, 0, 0, 0, 5203, 5204, 1, 0, 0, 0, 5204, 5206, 1, 0, + 0, 0, 5205, 5112, 1, 0, 0, 0, 5205, 5170, 1, 0, 0, 0, 5206, 433, 1, 0, + 0, 0, 5207, 5230, 5, 42, 0, 0, 5208, 5230, 5, 530, 0, 0, 5209, 5219, 5, + 6, 0, 0, 5210, 5211, 5, 59, 0, 0, 5211, 5216, 3, 564, 282, 0, 5212, 5213, + 5, 1140, 0, 0, 5213, 5215, 3, 564, 282, 0, 5214, 5212, 1, 0, 0, 0, 5215, + 5218, 1, 0, 0, 0, 5216, 5214, 1, 0, 0, 0, 5216, 5217, 1, 0, 0, 0, 5217, + 5220, 1, 0, 0, 0, 5218, 5216, 1, 0, 0, 0, 5219, 5210, 1, 0, 0, 0, 5219, + 5220, 1, 0, 0, 0, 5220, 5230, 1, 0, 0, 0, 5221, 5226, 3, 564, 282, 0, 5222, + 5223, 5, 1140, 0, 0, 5223, 5225, 3, 564, 282, 0, 5224, 5222, 1, 0, 0, 0, + 5225, 5228, 1, 0, 0, 0, 5226, 5224, 1, 0, 0, 0, 5226, 5227, 1, 0, 0, 0, + 5227, 5230, 1, 0, 0, 0, 5228, 5226, 1, 0, 0, 0, 5229, 5207, 1, 0, 0, 0, + 5229, 5208, 1, 0, 0, 0, 5229, 5209, 1, 0, 0, 0, 5229, 5221, 1, 0, 0, 0, + 5230, 435, 1, 0, 0, 0, 5231, 5232, 5, 72, 0, 0, 5232, 5233, 5, 567, 0, + 0, 5233, 5234, 5, 118, 0, 0, 5234, 5235, 3, 564, 282, 0, 5235, 5236, 5, + 175, 0, 0, 5236, 5241, 3, 564, 282, 0, 5237, 5238, 5, 1140, 0, 0, 5238, + 5240, 3, 564, 282, 0, 5239, 5237, 1, 0, 0, 0, 5240, 5243, 1, 0, 0, 0, 5241, + 5239, 1, 0, 0, 0, 5241, 5242, 1, 0, 0, 0, 5242, 5247, 1, 0, 0, 0, 5243, + 5241, 1, 0, 0, 0, 5244, 5245, 5, 192, 0, 0, 5245, 5246, 5, 72, 0, 0, 5246, + 5248, 5, 120, 0, 0, 5247, 5244, 1, 0, 0, 0, 5247, 5248, 1, 0, 0, 0, 5248, + 437, 1, 0, 0, 0, 5249, 5250, 5, 139, 0, 0, 5250, 5251, 5, 666, 0, 0, 5251, + 5256, 3, 468, 234, 0, 5252, 5253, 5, 1140, 0, 0, 5253, 5255, 3, 468, 234, + 0, 5254, 5252, 1, 0, 0, 0, 5255, 5258, 1, 0, 0, 0, 5256, 5254, 1, 0, 0, + 0, 5256, 5257, 1, 0, 0, 0, 5257, 439, 1, 0, 0, 0, 5258, 5256, 1, 0, 0, + 0, 5259, 5261, 5, 147, 0, 0, 5260, 5262, 3, 640, 320, 0, 5261, 5260, 1, + 0, 0, 0, 5261, 5262, 1, 0, 0, 0, 5262, 5265, 1, 0, 0, 0, 5263, 5266, 3, + 462, 231, 0, 5264, 5266, 3, 584, 292, 0, 5265, 5263, 1, 0, 0, 0, 5265, + 5264, 1, 0, 0, 0, 5266, 5272, 1, 0, 0, 0, 5267, 5268, 5, 1140, 0, 0, 5268, + 5271, 3, 462, 231, 0, 5269, 5271, 3, 584, 292, 0, 5270, 5267, 1, 0, 0, + 0, 5270, 5269, 1, 0, 0, 0, 5271, 5274, 1, 0, 0, 0, 5272, 5270, 1, 0, 0, + 0, 5272, 5273, 1, 0, 0, 0, 5273, 5275, 1, 0, 0, 0, 5274, 5272, 1, 0, 0, + 0, 5275, 5277, 5, 118, 0, 0, 5276, 5278, 7, 66, 0, 0, 5277, 5276, 1, 0, + 0, 0, 5277, 5278, 1, 0, 0, 0, 5278, 5279, 1, 0, 0, 0, 5279, 5280, 3, 466, + 233, 0, 5280, 5281, 5, 68, 0, 0, 5281, 5286, 3, 564, 282, 0, 5282, 5283, + 5, 1140, 0, 0, 5283, 5285, 3, 564, 282, 0, 5284, 5282, 1, 0, 0, 0, 5285, + 5288, 1, 0, 0, 0, 5286, 5284, 1, 0, 0, 0, 5286, 5287, 1, 0, 0, 0, 5287, + 5292, 1, 0, 0, 0, 5288, 5286, 1, 0, 0, 0, 5289, 5290, 5, 78, 0, 0, 5290, + 5291, 5, 663, 0, 0, 5291, 5293, 5, 666, 0, 0, 5292, 5289, 1, 0, 0, 0, 5292, + 5293, 1, 0, 0, 0, 5293, 5358, 1, 0, 0, 0, 5294, 5296, 5, 147, 0, 0, 5295, + 5297, 3, 640, 320, 0, 5296, 5295, 1, 0, 0, 0, 5296, 5297, 1, 0, 0, 0, 5297, + 5298, 1, 0, 0, 0, 5298, 5300, 5, 6, 0, 0, 5299, 5301, 5, 726, 0, 0, 5300, + 5299, 1, 0, 0, 0, 5300, 5301, 1, 0, 0, 0, 5301, 5302, 1, 0, 0, 0, 5302, + 5303, 5, 1140, 0, 0, 5303, 5304, 5, 72, 0, 0, 5304, 5305, 5, 120, 0, 0, + 5305, 5306, 5, 68, 0, 0, 5306, 5311, 3, 564, 282, 0, 5307, 5308, 5, 1140, + 0, 0, 5308, 5310, 3, 564, 282, 0, 5309, 5307, 1, 0, 0, 0, 5310, 5313, 1, + 0, 0, 0, 5311, 5309, 1, 0, 0, 0, 5311, 5312, 1, 0, 0, 0, 5312, 5317, 1, + 0, 0, 0, 5313, 5311, 1, 0, 0, 0, 5314, 5315, 5, 78, 0, 0, 5315, 5316, 5, + 663, 0, 0, 5316, 5318, 5, 666, 0, 0, 5317, 5314, 1, 0, 0, 0, 5317, 5318, + 1, 0, 0, 0, 5318, 5358, 1, 0, 0, 0, 5319, 5321, 5, 147, 0, 0, 5320, 5322, + 3, 640, 320, 0, 5321, 5320, 1, 0, 0, 0, 5321, 5322, 1, 0, 0, 0, 5322, 5325, + 1, 0, 0, 0, 5323, 5326, 3, 564, 282, 0, 5324, 5326, 3, 584, 292, 0, 5325, + 5323, 1, 0, 0, 0, 5325, 5324, 1, 0, 0, 0, 5326, 5334, 1, 0, 0, 0, 5327, + 5330, 5, 1140, 0, 0, 5328, 5331, 3, 564, 282, 0, 5329, 5331, 3, 584, 292, + 0, 5330, 5328, 1, 0, 0, 0, 5330, 5329, 1, 0, 0, 0, 5331, 5333, 1, 0, 0, + 0, 5332, 5327, 1, 0, 0, 0, 5333, 5336, 1, 0, 0, 0, 5334, 5332, 1, 0, 0, + 0, 5334, 5335, 1, 0, 0, 0, 5335, 5337, 1, 0, 0, 0, 5336, 5334, 1, 0, 0, + 0, 5337, 5340, 5, 68, 0, 0, 5338, 5341, 3, 564, 282, 0, 5339, 5341, 3, + 584, 292, 0, 5340, 5338, 1, 0, 0, 0, 5340, 5339, 1, 0, 0, 0, 5341, 5349, + 1, 0, 0, 0, 5342, 5345, 5, 1140, 0, 0, 5343, 5346, 3, 564, 282, 0, 5344, + 5346, 3, 584, 292, 0, 5345, 5343, 1, 0, 0, 0, 5345, 5344, 1, 0, 0, 0, 5346, + 5348, 1, 0, 0, 0, 5347, 5342, 1, 0, 0, 0, 5348, 5351, 1, 0, 0, 0, 5349, + 5347, 1, 0, 0, 0, 5349, 5350, 1, 0, 0, 0, 5350, 5355, 1, 0, 0, 0, 5351, + 5349, 1, 0, 0, 0, 5352, 5353, 5, 78, 0, 0, 5353, 5354, 5, 663, 0, 0, 5354, + 5356, 5, 666, 0, 0, 5355, 5352, 1, 0, 0, 0, 5355, 5356, 1, 0, 0, 0, 5356, + 5358, 1, 0, 0, 0, 5357, 5259, 1, 0, 0, 0, 5357, 5294, 1, 0, 0, 0, 5357, + 5319, 1, 0, 0, 0, 5358, 441, 1, 0, 0, 0, 5359, 5360, 5, 147, 0, 0, 5360, + 5361, 5, 567, 0, 0, 5361, 5362, 5, 118, 0, 0, 5362, 5363, 3, 564, 282, + 0, 5363, 5364, 5, 68, 0, 0, 5364, 5369, 3, 564, 282, 0, 5365, 5366, 5, + 1140, 0, 0, 5366, 5368, 3, 564, 282, 0, 5367, 5365, 1, 0, 0, 0, 5368, 5371, + 1, 0, 0, 0, 5369, 5367, 1, 0, 0, 0, 5369, 5370, 1, 0, 0, 0, 5370, 443, + 1, 0, 0, 0, 5371, 5369, 1, 0, 0, 0, 5372, 5373, 5, 153, 0, 0, 5373, 5376, + 5, 552, 0, 0, 5374, 5375, 5, 65, 0, 0, 5375, 5377, 3, 564, 282, 0, 5376, + 5374, 1, 0, 0, 0, 5376, 5377, 1, 0, 0, 0, 5377, 5378, 1, 0, 0, 0, 5378, + 5381, 5, 1129, 0, 0, 5379, 5382, 3, 682, 341, 0, 5380, 5382, 5, 1153, 0, + 0, 5381, 5379, 1, 0, 0, 0, 5381, 5380, 1, 0, 0, 0, 5382, 445, 1, 0, 0, + 0, 5383, 5384, 3, 564, 282, 0, 5384, 5385, 3, 458, 229, 0, 5385, 447, 1, + 0, 0, 0, 5386, 5387, 3, 564, 282, 0, 5387, 5388, 5, 449, 0, 0, 5388, 5389, + 5, 19, 0, 0, 5389, 5390, 5, 552, 0, 0, 5390, 5391, 5, 1153, 0, 0, 5391, + 5412, 1, 0, 0, 0, 5392, 5393, 3, 564, 282, 0, 5393, 5394, 5, 449, 0, 0, + 5394, 5395, 5, 19, 0, 0, 5395, 5396, 5, 993, 0, 0, 5396, 5397, 5, 552, + 0, 0, 5397, 5398, 3, 450, 225, 0, 5398, 5412, 1, 0, 0, 0, 5399, 5400, 3, + 564, 282, 0, 5400, 5401, 5, 449, 0, 0, 5401, 5402, 5, 19, 0, 0, 5402, 5403, + 5, 1153, 0, 0, 5403, 5404, 3, 450, 225, 0, 5404, 5412, 1, 0, 0, 0, 5405, + 5406, 3, 564, 282, 0, 5406, 5407, 5, 449, 0, 0, 5407, 5408, 5, 192, 0, + 0, 5408, 5409, 3, 452, 226, 0, 5409, 5412, 1, 0, 0, 0, 5410, 5412, 3, 564, + 282, 0, 5411, 5386, 1, 0, 0, 0, 5411, 5392, 1, 0, 0, 0, 5411, 5399, 1, + 0, 0, 0, 5411, 5405, 1, 0, 0, 0, 5411, 5410, 1, 0, 0, 0, 5412, 449, 1, + 0, 0, 0, 5413, 5414, 5, 141, 0, 0, 5414, 5416, 5, 1153, 0, 0, 5415, 5413, + 1, 0, 0, 0, 5415, 5416, 1, 0, 0, 0, 5416, 5420, 1, 0, 0, 0, 5417, 5418, + 5, 145, 0, 0, 5418, 5419, 5, 35, 0, 0, 5419, 5421, 5, 552, 0, 0, 5420, + 5417, 1, 0, 0, 0, 5420, 5421, 1, 0, 0, 0, 5421, 451, 1, 0, 0, 0, 5422, + 5430, 3, 582, 291, 0, 5423, 5427, 7, 67, 0, 0, 5424, 5428, 5, 1153, 0, + 0, 5425, 5426, 5, 993, 0, 0, 5426, 5428, 5, 552, 0, 0, 5427, 5424, 1, 0, + 0, 0, 5427, 5425, 1, 0, 0, 0, 5428, 5429, 1, 0, 0, 0, 5429, 5431, 3, 450, + 225, 0, 5430, 5423, 1, 0, 0, 0, 5430, 5431, 1, 0, 0, 0, 5431, 5437, 1, + 0, 0, 0, 5432, 5433, 3, 582, 291, 0, 5433, 5434, 5, 187, 0, 0, 5434, 5435, + 3, 682, 341, 0, 5435, 5437, 1, 0, 0, 0, 5436, 5422, 1, 0, 0, 0, 5436, 5432, + 1, 0, 0, 0, 5437, 453, 1, 0, 0, 0, 5438, 5447, 5, 167, 0, 0, 5439, 5447, + 5, 681, 0, 0, 5440, 5441, 5, 359, 0, 0, 5441, 5447, 5, 1153, 0, 0, 5442, + 5443, 5, 466, 0, 0, 5443, 5447, 5, 1153, 0, 0, 5444, 5445, 5, 641, 0, 0, + 5445, 5447, 5, 1153, 0, 0, 5446, 5438, 1, 0, 0, 0, 5446, 5439, 1, 0, 0, + 0, 5446, 5440, 1, 0, 0, 0, 5446, 5442, 1, 0, 0, 0, 5446, 5444, 1, 0, 0, + 0, 5447, 455, 1, 0, 0, 0, 5448, 5449, 5, 500, 0, 0, 5449, 5457, 3, 590, + 295, 0, 5450, 5451, 5, 503, 0, 0, 5451, 5457, 3, 590, 295, 0, 5452, 5453, + 5, 499, 0, 0, 5453, 5457, 3, 590, 295, 0, 5454, 5455, 5, 504, 0, 0, 5455, + 5457, 3, 590, 295, 0, 5456, 5448, 1, 0, 0, 0, 5456, 5450, 1, 0, 0, 0, 5456, + 5452, 1, 0, 0, 0, 5456, 5454, 1, 0, 0, 0, 5457, 457, 1, 0, 0, 0, 5458, + 5459, 5, 552, 0, 0, 5459, 5466, 5, 421, 0, 0, 5460, 5467, 5, 42, 0, 0, + 5461, 5467, 5, 520, 0, 0, 5462, 5463, 5, 86, 0, 0, 5463, 5464, 3, 590, + 295, 0, 5464, 5465, 5, 692, 0, 0, 5465, 5467, 1, 0, 0, 0, 5466, 5460, 1, + 0, 0, 0, 5466, 5461, 1, 0, 0, 0, 5466, 5462, 1, 0, 0, 0, 5466, 5467, 1, + 0, 0, 0, 5467, 5497, 1, 0, 0, 0, 5468, 5469, 5, 552, 0, 0, 5469, 5472, + 5, 446, 0, 0, 5470, 5473, 5, 42, 0, 0, 5471, 5473, 3, 590, 295, 0, 5472, + 5470, 1, 0, 0, 0, 5472, 5471, 1, 0, 0, 0, 5473, 5497, 1, 0, 0, 0, 5474, + 5475, 5, 552, 0, 0, 5475, 5476, 5, 596, 0, 0, 5476, 5481, 5, 86, 0, 0, + 5477, 5482, 5, 42, 0, 0, 5478, 5479, 3, 590, 295, 0, 5479, 5480, 5, 692, + 0, 0, 5480, 5482, 1, 0, 0, 0, 5481, 5477, 1, 0, 0, 0, 5481, 5478, 1, 0, + 0, 0, 5482, 5497, 1, 0, 0, 0, 5483, 5484, 5, 552, 0, 0, 5484, 5485, 5, + 142, 0, 0, 5485, 5487, 5, 35, 0, 0, 5486, 5488, 7, 68, 0, 0, 5487, 5486, + 1, 0, 0, 0, 5487, 5488, 1, 0, 0, 0, 5488, 5497, 1, 0, 0, 0, 5489, 5490, + 5, 425, 0, 0, 5490, 5497, 3, 590, 295, 0, 5491, 5494, 5, 553, 0, 0, 5492, + 5495, 3, 590, 295, 0, 5493, 5495, 5, 658, 0, 0, 5494, 5492, 1, 0, 0, 0, + 5494, 5493, 1, 0, 0, 0, 5495, 5497, 1, 0, 0, 0, 5496, 5458, 1, 0, 0, 0, + 5496, 5468, 1, 0, 0, 0, 5496, 5474, 1, 0, 0, 0, 5496, 5483, 1, 0, 0, 0, + 5496, 5489, 1, 0, 0, 0, 5496, 5491, 1, 0, 0, 0, 5497, 459, 1, 0, 0, 0, + 5498, 5499, 5, 333, 0, 0, 5499, 5500, 7, 69, 0, 0, 5500, 461, 1, 0, 0, + 0, 5501, 5506, 3, 464, 232, 0, 5502, 5503, 5, 1138, 0, 0, 5503, 5504, 3, + 616, 308, 0, 5504, 5505, 5, 1139, 0, 0, 5505, 5507, 1, 0, 0, 0, 5506, 5502, + 1, 0, 0, 0, 5506, 5507, 1, 0, 0, 0, 5507, 463, 1, 0, 0, 0, 5508, 5510, + 5, 6, 0, 0, 5509, 5511, 5, 726, 0, 0, 5510, 5509, 1, 0, 0, 0, 5510, 5511, + 1, 0, 0, 0, 5511, 5602, 1, 0, 0, 0, 5512, 5514, 5, 7, 0, 0, 5513, 5515, + 5, 734, 0, 0, 5514, 5513, 1, 0, 0, 0, 5514, 5515, 1, 0, 0, 0, 5515, 5602, + 1, 0, 0, 0, 5516, 5524, 5, 33, 0, 0, 5517, 5518, 5, 650, 0, 0, 5518, 5525, + 5, 743, 0, 0, 5519, 5525, 5, 734, 0, 0, 5520, 5525, 5, 672, 0, 0, 5521, + 5525, 5, 666, 0, 0, 5522, 5525, 5, 648, 0, 0, 5523, 5525, 5, 597, 0, 0, + 5524, 5517, 1, 0, 0, 0, 5524, 5519, 1, 0, 0, 0, 5524, 5520, 1, 0, 0, 0, + 5524, 5521, 1, 0, 0, 0, 5524, 5522, 1, 0, 0, 0, 5524, 5523, 1, 0, 0, 0, + 5524, 5525, 1, 0, 0, 0, 5525, 5602, 1, 0, 0, 0, 5526, 5602, 5, 44, 0, 0, + 5527, 5529, 5, 51, 0, 0, 5528, 5530, 5, 597, 0, 0, 5529, 5528, 1, 0, 0, + 0, 5529, 5530, 1, 0, 0, 0, 5530, 5602, 1, 0, 0, 0, 5531, 5602, 5, 416, + 0, 0, 5532, 5602, 5, 709, 0, 0, 5533, 5602, 5, 710, 0, 0, 5534, 5535, 5, + 72, 0, 0, 5535, 5602, 5, 120, 0, 0, 5536, 5602, 5, 81, 0, 0, 5537, 5602, + 5, 85, 0, 0, 5538, 5539, 5, 103, 0, 0, 5539, 5602, 5, 743, 0, 0, 5540, + 5602, 5, 727, 0, 0, 5541, 5602, 5, 567, 0, 0, 5542, 5602, 5, 136, 0, 0, + 5543, 5602, 5, 728, 0, 0, 5544, 5545, 5, 589, 0, 0, 5545, 5602, 7, 70, + 0, 0, 5546, 5602, 5, 152, 0, 0, 5547, 5548, 5, 155, 0, 0, 5548, 5602, 7, + 71, 0, 0, 5549, 5602, 5, 740, 0, 0, 5550, 5602, 5, 741, 0, 0, 5551, 5602, + 5, 177, 0, 0, 5552, 5602, 5, 184, 0, 0, 5553, 5602, 5, 185, 0, 0, 5554, + 5602, 5, 699, 0, 0, 5555, 5602, 5, 700, 0, 0, 5556, 5602, 5, 701, 0, 0, + 5557, 5602, 5, 702, 0, 0, 5558, 5602, 5, 703, 0, 0, 5559, 5602, 5, 704, + 0, 0, 5560, 5602, 5, 705, 0, 0, 5561, 5602, 5, 706, 0, 0, 5562, 5602, 5, + 707, 0, 0, 5563, 5602, 5, 708, 0, 0, 5564, 5602, 5, 711, 0, 0, 5565, 5602, + 5, 712, 0, 0, 5566, 5602, 5, 713, 0, 0, 5567, 5602, 5, 714, 0, 0, 5568, + 5602, 5, 715, 0, 0, 5569, 5602, 5, 716, 0, 0, 5570, 5602, 5, 717, 0, 0, + 5571, 5602, 5, 718, 0, 0, 5572, 5602, 5, 719, 0, 0, 5573, 5602, 5, 720, + 0, 0, 5574, 5602, 5, 723, 0, 0, 5575, 5602, 5, 724, 0, 0, 5576, 5602, 5, + 725, 0, 0, 5577, 5602, 5, 729, 0, 0, 5578, 5602, 5, 730, 0, 0, 5579, 5602, + 5, 731, 0, 0, 5580, 5602, 5, 732, 0, 0, 5581, 5602, 5, 733, 0, 0, 5582, + 5602, 5, 736, 0, 0, 5583, 5602, 5, 737, 0, 0, 5584, 5602, 5, 738, 0, 0, + 5585, 5602, 5, 158, 0, 0, 5586, 5602, 5, 739, 0, 0, 5587, 5602, 5, 1080, + 0, 0, 5588, 5602, 5, 742, 0, 0, 5589, 5602, 5, 744, 0, 0, 5590, 5602, 5, + 1091, 0, 0, 5591, 5602, 5, 745, 0, 0, 5592, 5602, 5, 746, 0, 0, 5593, 5594, + 5, 102, 0, 0, 5594, 5595, 5, 68, 0, 0, 5595, 5602, 5, 735, 0, 0, 5596, + 5597, 5, 152, 0, 0, 5597, 5598, 5, 87, 0, 0, 5598, 5602, 5, 735, 0, 0, + 5599, 5600, 5, 721, 0, 0, 5600, 5602, 5, 722, 0, 0, 5601, 5508, 1, 0, 0, + 0, 5601, 5512, 1, 0, 0, 0, 5601, 5516, 1, 0, 0, 0, 5601, 5526, 1, 0, 0, + 0, 5601, 5527, 1, 0, 0, 0, 5601, 5531, 1, 0, 0, 0, 5601, 5532, 1, 0, 0, + 0, 5601, 5533, 1, 0, 0, 0, 5601, 5534, 1, 0, 0, 0, 5601, 5536, 1, 0, 0, + 0, 5601, 5537, 1, 0, 0, 0, 5601, 5538, 1, 0, 0, 0, 5601, 5540, 1, 0, 0, + 0, 5601, 5541, 1, 0, 0, 0, 5601, 5542, 1, 0, 0, 0, 5601, 5543, 1, 0, 0, + 0, 5601, 5544, 1, 0, 0, 0, 5601, 5546, 1, 0, 0, 0, 5601, 5547, 1, 0, 0, + 0, 5601, 5549, 1, 0, 0, 0, 5601, 5550, 1, 0, 0, 0, 5601, 5551, 1, 0, 0, + 0, 5601, 5552, 1, 0, 0, 0, 5601, 5553, 1, 0, 0, 0, 5601, 5554, 1, 0, 0, + 0, 5601, 5555, 1, 0, 0, 0, 5601, 5556, 1, 0, 0, 0, 5601, 5557, 1, 0, 0, + 0, 5601, 5558, 1, 0, 0, 0, 5601, 5559, 1, 0, 0, 0, 5601, 5560, 1, 0, 0, + 0, 5601, 5561, 1, 0, 0, 0, 5601, 5562, 1, 0, 0, 0, 5601, 5563, 1, 0, 0, + 0, 5601, 5564, 1, 0, 0, 0, 5601, 5565, 1, 0, 0, 0, 5601, 5566, 1, 0, 0, + 0, 5601, 5567, 1, 0, 0, 0, 5601, 5568, 1, 0, 0, 0, 5601, 5569, 1, 0, 0, + 0, 5601, 5570, 1, 0, 0, 0, 5601, 5571, 1, 0, 0, 0, 5601, 5572, 1, 0, 0, + 0, 5601, 5573, 1, 0, 0, 0, 5601, 5574, 1, 0, 0, 0, 5601, 5575, 1, 0, 0, + 0, 5601, 5576, 1, 0, 0, 0, 5601, 5577, 1, 0, 0, 0, 5601, 5578, 1, 0, 0, + 0, 5601, 5579, 1, 0, 0, 0, 5601, 5580, 1, 0, 0, 0, 5601, 5581, 1, 0, 0, + 0, 5601, 5582, 1, 0, 0, 0, 5601, 5583, 1, 0, 0, 0, 5601, 5584, 1, 0, 0, + 0, 5601, 5585, 1, 0, 0, 0, 5601, 5586, 1, 0, 0, 0, 5601, 5587, 1, 0, 0, + 0, 5601, 5588, 1, 0, 0, 0, 5601, 5589, 1, 0, 0, 0, 5601, 5590, 1, 0, 0, + 0, 5601, 5591, 1, 0, 0, 0, 5601, 5592, 1, 0, 0, 0, 5601, 5593, 1, 0, 0, + 0, 5601, 5596, 1, 0, 0, 0, 5601, 5599, 1, 0, 0, 0, 5602, 465, 1, 0, 0, + 0, 5603, 5620, 5, 1122, 0, 0, 5604, 5605, 5, 1122, 0, 0, 5605, 5606, 5, + 1137, 0, 0, 5606, 5620, 5, 1122, 0, 0, 5607, 5608, 3, 584, 292, 0, 5608, + 5609, 5, 1137, 0, 0, 5609, 5610, 5, 1122, 0, 0, 5610, 5620, 1, 0, 0, 0, + 5611, 5612, 3, 584, 292, 0, 5612, 5613, 5, 1137, 0, 0, 5613, 5614, 3, 584, + 292, 0, 5614, 5620, 1, 0, 0, 0, 5615, 5616, 3, 584, 292, 0, 5616, 5617, + 3, 588, 294, 0, 5617, 5620, 1, 0, 0, 0, 5618, 5620, 3, 584, 292, 0, 5619, + 5603, 1, 0, 0, 0, 5619, 5604, 1, 0, 0, 0, 5619, 5607, 1, 0, 0, 0, 5619, + 5611, 1, 0, 0, 0, 5619, 5615, 1, 0, 0, 0, 5619, 5618, 1, 0, 0, 0, 5620, + 467, 1, 0, 0, 0, 5621, 5622, 3, 564, 282, 0, 5622, 5623, 5, 175, 0, 0, + 5623, 5624, 3, 564, 282, 0, 5624, 469, 1, 0, 0, 0, 5625, 5627, 5, 9, 0, + 0, 5626, 5628, 7, 72, 0, 0, 5627, 5626, 1, 0, 0, 0, 5627, 5628, 1, 0, 0, + 0, 5628, 5629, 1, 0, 0, 0, 5629, 5630, 7, 54, 0, 0, 5630, 5648, 3, 620, + 310, 0, 5631, 5632, 5, 184, 0, 0, 5632, 5633, 5, 76, 0, 0, 5633, 5634, + 5, 118, 0, 0, 5634, 5639, 3, 556, 278, 0, 5635, 5636, 5, 1140, 0, 0, 5636, + 5638, 3, 556, 278, 0, 5637, 5635, 1, 0, 0, 0, 5638, 5641, 1, 0, 0, 0, 5639, + 5637, 1, 0, 0, 0, 5639, 5640, 1, 0, 0, 0, 5640, 5646, 1, 0, 0, 0, 5641, + 5639, 1, 0, 0, 0, 5642, 5643, 5, 192, 0, 0, 5643, 5644, 3, 590, 295, 0, + 5644, 5645, 5, 18, 0, 0, 5645, 5647, 1, 0, 0, 0, 5646, 5642, 1, 0, 0, 0, + 5646, 5647, 1, 0, 0, 0, 5647, 5649, 1, 0, 0, 0, 5648, 5631, 1, 0, 0, 0, + 5648, 5649, 1, 0, 0, 0, 5649, 5661, 1, 0, 0, 0, 5650, 5651, 5, 51, 0, 0, + 5651, 5652, 5, 76, 0, 0, 5652, 5653, 5, 118, 0, 0, 5653, 5658, 3, 556, + 278, 0, 5654, 5655, 5, 1140, 0, 0, 5655, 5657, 3, 556, 278, 0, 5656, 5654, + 1, 0, 0, 0, 5657, 5660, 1, 0, 0, 0, 5658, 5656, 1, 0, 0, 0, 5658, 5659, + 1, 0, 0, 0, 5659, 5662, 1, 0, 0, 0, 5660, 5658, 1, 0, 0, 0, 5661, 5650, + 1, 0, 0, 0, 5661, 5662, 1, 0, 0, 0, 5662, 471, 1, 0, 0, 0, 5663, 5664, + 5, 26, 0, 0, 5664, 5665, 5, 172, 0, 0, 5665, 5669, 3, 620, 310, 0, 5666, + 5668, 3, 480, 240, 0, 5667, 5666, 1, 0, 0, 0, 5668, 5671, 1, 0, 0, 0, 5669, + 5667, 1, 0, 0, 0, 5669, 5670, 1, 0, 0, 0, 5670, 473, 1, 0, 0, 0, 5671, + 5669, 1, 0, 0, 0, 5672, 5673, 5, 357, 0, 0, 5673, 5674, 5, 172, 0, 0, 5674, + 5676, 3, 620, 310, 0, 5675, 5677, 7, 73, 0, 0, 5676, 5675, 1, 0, 0, 0, + 5676, 5677, 1, 0, 0, 0, 5677, 475, 1, 0, 0, 0, 5678, 5680, 5, 119, 0, 0, + 5679, 5681, 7, 72, 0, 0, 5680, 5679, 1, 0, 0, 0, 5680, 5681, 1, 0, 0, 0, + 5681, 5682, 1, 0, 0, 0, 5682, 5683, 7, 54, 0, 0, 5683, 5684, 3, 620, 310, + 0, 5684, 477, 1, 0, 0, 0, 5685, 5687, 5, 581, 0, 0, 5686, 5688, 7, 72, + 0, 0, 5687, 5686, 1, 0, 0, 0, 5687, 5688, 1, 0, 0, 0, 5688, 5689, 1, 0, + 0, 0, 5689, 5690, 5, 172, 0, 0, 5690, 5692, 3, 620, 310, 0, 5691, 5693, + 5, 569, 0, 0, 5692, 5691, 1, 0, 0, 0, 5692, 5693, 1, 0, 0, 0, 5693, 5695, + 1, 0, 0, 0, 5694, 5696, 5, 423, 0, 0, 5695, 5694, 1, 0, 0, 0, 5695, 5696, + 1, 0, 0, 0, 5696, 5698, 1, 0, 0, 0, 5697, 5699, 5, 667, 0, 0, 5698, 5697, + 1, 0, 0, 0, 5698, 5699, 1, 0, 0, 0, 5699, 479, 1, 0, 0, 0, 5700, 5701, + 5, 65, 0, 0, 5701, 5708, 5, 665, 0, 0, 5702, 5708, 5, 569, 0, 0, 5703, + 5708, 5, 426, 0, 0, 5704, 5708, 5, 505, 0, 0, 5705, 5708, 5, 423, 0, 0, + 5706, 5708, 5, 355, 0, 0, 5707, 5700, 1, 0, 0, 0, 5707, 5702, 1, 0, 0, + 0, 5707, 5703, 1, 0, 0, 0, 5707, 5704, 1, 0, 0, 0, 5707, 5705, 1, 0, 0, + 0, 5707, 5706, 1, 0, 0, 0, 5708, 481, 1, 0, 0, 0, 5709, 5711, 5, 33, 0, + 0, 5710, 5712, 5, 336, 0, 0, 5711, 5710, 1, 0, 0, 0, 5711, 5712, 1, 0, + 0, 0, 5712, 5713, 1, 0, 0, 0, 5713, 5715, 5, 438, 0, 0, 5714, 5716, 3, + 642, 321, 0, 5715, 5714, 1, 0, 0, 0, 5715, 5716, 1, 0, 0, 0, 5716, 5717, + 1, 0, 0, 0, 5717, 5718, 3, 584, 292, 0, 5718, 5719, 5, 595, 0, 0, 5719, + 5720, 7, 74, 0, 0, 5720, 5721, 5, 620, 0, 0, 5721, 5722, 5, 1153, 0, 0, + 5722, 483, 1, 0, 0, 0, 5723, 5724, 5, 457, 0, 0, 5724, 5725, 5, 555, 0, + 0, 5725, 5726, 3, 584, 292, 0, 5726, 5727, 5, 620, 0, 0, 5727, 5728, 5, + 1153, 0, 0, 5728, 485, 1, 0, 0, 0, 5729, 5730, 5, 662, 0, 0, 5730, 5731, + 5, 555, 0, 0, 5731, 5732, 3, 584, 292, 0, 5732, 487, 1, 0, 0, 0, 5733, + 5734, 5, 153, 0, 0, 5734, 5735, 3, 492, 246, 0, 5735, 5738, 7, 75, 0, 0, + 5736, 5739, 3, 688, 344, 0, 5737, 5739, 5, 118, 0, 0, 5738, 5736, 1, 0, + 0, 0, 5738, 5737, 1, 0, 0, 0, 5739, 5749, 1, 0, 0, 0, 5740, 5741, 5, 1140, + 0, 0, 5741, 5742, 3, 492, 246, 0, 5742, 5745, 7, 75, 0, 0, 5743, 5746, + 3, 688, 344, 0, 5744, 5746, 5, 118, 0, 0, 5745, 5743, 1, 0, 0, 0, 5745, + 5744, 1, 0, 0, 0, 5746, 5748, 1, 0, 0, 0, 5747, 5740, 1, 0, 0, 0, 5748, + 5751, 1, 0, 0, 0, 5749, 5747, 1, 0, 0, 0, 5749, 5750, 1, 0, 0, 0, 5750, + 5786, 1, 0, 0, 0, 5751, 5749, 1, 0, 0, 0, 5752, 5753, 5, 153, 0, 0, 5753, + 5756, 3, 60, 30, 0, 5754, 5757, 3, 568, 284, 0, 5755, 5757, 5, 42, 0, 0, + 5756, 5754, 1, 0, 0, 0, 5756, 5755, 1, 0, 0, 0, 5757, 5786, 1, 0, 0, 0, + 5758, 5759, 5, 153, 0, 0, 5759, 5766, 5, 518, 0, 0, 5760, 5763, 3, 568, + 284, 0, 5761, 5762, 5, 27, 0, 0, 5762, 5764, 3, 570, 285, 0, 5763, 5761, + 1, 0, 0, 0, 5763, 5764, 1, 0, 0, 0, 5764, 5767, 1, 0, 0, 0, 5765, 5767, + 5, 42, 0, 0, 5766, 5760, 1, 0, 0, 0, 5766, 5765, 1, 0, 0, 0, 5767, 5786, + 1, 0, 0, 0, 5768, 5786, 3, 444, 222, 0, 5769, 5786, 3, 318, 159, 0, 5770, + 5786, 3, 316, 158, 0, 5771, 5772, 5, 153, 0, 0, 5772, 5773, 3, 550, 275, + 0, 5773, 5774, 7, 75, 0, 0, 5774, 5782, 3, 688, 344, 0, 5775, 5776, 5, + 1140, 0, 0, 5776, 5777, 3, 550, 275, 0, 5777, 5778, 7, 75, 0, 0, 5778, + 5779, 3, 688, 344, 0, 5779, 5781, 1, 0, 0, 0, 5780, 5775, 1, 0, 0, 0, 5781, + 5784, 1, 0, 0, 0, 5782, 5780, 1, 0, 0, 0, 5782, 5783, 1, 0, 0, 0, 5783, + 5786, 1, 0, 0, 0, 5784, 5782, 1, 0, 0, 0, 5785, 5733, 1, 0, 0, 0, 5785, + 5752, 1, 0, 0, 0, 5785, 5758, 1, 0, 0, 0, 5785, 5768, 1, 0, 0, 0, 5785, + 5769, 1, 0, 0, 0, 5785, 5770, 1, 0, 0, 0, 5785, 5771, 1, 0, 0, 0, 5786, + 489, 1, 0, 0, 0, 5787, 5788, 5, 155, 0, 0, 5788, 5789, 7, 56, 0, 0, 5789, + 5941, 5, 477, 0, 0, 5790, 5791, 5, 155, 0, 0, 5791, 5792, 7, 76, 0, 0, + 5792, 5795, 5, 417, 0, 0, 5793, 5794, 5, 80, 0, 0, 5794, 5796, 5, 1153, + 0, 0, 5795, 5793, 1, 0, 0, 0, 5795, 5796, 1, 0, 0, 0, 5796, 5799, 1, 0, + 0, 0, 5797, 5798, 5, 68, 0, 0, 5798, 5800, 3, 590, 295, 0, 5799, 5797, + 1, 0, 0, 0, 5799, 5800, 1, 0, 0, 0, 5800, 5808, 1, 0, 0, 0, 5801, 5805, + 5, 99, 0, 0, 5802, 5803, 3, 590, 295, 0, 5803, 5804, 5, 1140, 0, 0, 5804, + 5806, 1, 0, 0, 0, 5805, 5802, 1, 0, 0, 0, 5805, 5806, 1, 0, 0, 0, 5806, + 5807, 1, 0, 0, 0, 5807, 5809, 3, 590, 295, 0, 5808, 5801, 1, 0, 0, 0, 5808, + 5809, 1, 0, 0, 0, 5809, 5941, 1, 0, 0, 0, 5810, 5811, 5, 155, 0, 0, 5811, + 5813, 3, 494, 247, 0, 5812, 5814, 3, 496, 248, 0, 5813, 5812, 1, 0, 0, + 0, 5813, 5814, 1, 0, 0, 0, 5814, 5941, 1, 0, 0, 0, 5815, 5817, 5, 155, + 0, 0, 5816, 5818, 5, 437, 0, 0, 5817, 5816, 1, 0, 0, 0, 5817, 5818, 1, + 0, 0, 0, 5818, 5819, 1, 0, 0, 0, 5819, 5820, 7, 41, 0, 0, 5820, 5821, 7, + 77, 0, 0, 5821, 5824, 3, 552, 276, 0, 5822, 5823, 7, 77, 0, 0, 5823, 5825, + 3, 584, 292, 0, 5824, 5822, 1, 0, 0, 0, 5824, 5825, 1, 0, 0, 0, 5825, 5827, + 1, 0, 0, 0, 5826, 5828, 3, 496, 248, 0, 5827, 5826, 1, 0, 0, 0, 5827, 5828, + 1, 0, 0, 0, 5828, 5941, 1, 0, 0, 0, 5829, 5830, 5, 155, 0, 0, 5830, 5831, + 5, 33, 0, 0, 5831, 5833, 7, 0, 0, 0, 5832, 5834, 3, 642, 321, 0, 5833, + 5832, 1, 0, 0, 0, 5833, 5834, 1, 0, 0, 0, 5834, 5835, 1, 0, 0, 0, 5835, + 5941, 3, 584, 292, 0, 5836, 5837, 5, 155, 0, 0, 5837, 5838, 5, 33, 0, 0, + 5838, 5839, 7, 78, 0, 0, 5839, 5941, 3, 550, 275, 0, 5840, 5841, 5, 155, + 0, 0, 5841, 5842, 5, 33, 0, 0, 5842, 5843, 5, 666, 0, 0, 5843, 5941, 3, + 564, 282, 0, 5844, 5845, 5, 155, 0, 0, 5845, 5846, 5, 410, 0, 0, 5846, + 5847, 3, 572, 286, 0, 5847, 5848, 7, 79, 0, 0, 5848, 5941, 1, 0, 0, 0, + 5849, 5850, 5, 155, 0, 0, 5850, 5941, 3, 498, 249, 0, 5851, 5852, 5, 155, + 0, 0, 5852, 5860, 7, 80, 0, 0, 5853, 5857, 5, 99, 0, 0, 5854, 5855, 3, + 590, 295, 0, 5855, 5856, 5, 1140, 0, 0, 5856, 5858, 1, 0, 0, 0, 5857, 5854, + 1, 0, 0, 0, 5857, 5858, 1, 0, 0, 0, 5858, 5859, 1, 0, 0, 0, 5859, 5861, + 3, 590, 295, 0, 5860, 5853, 1, 0, 0, 0, 5860, 5861, 1, 0, 0, 0, 5861, 5941, + 1, 0, 0, 0, 5862, 5863, 5, 155, 0, 0, 5863, 5864, 5, 291, 0, 0, 5864, 5865, + 5, 1138, 0, 0, 5865, 5866, 5, 1122, 0, 0, 5866, 5867, 5, 1139, 0, 0, 5867, + 5941, 7, 80, 0, 0, 5868, 5869, 5, 155, 0, 0, 5869, 5872, 3, 500, 250, 0, + 5870, 5871, 7, 77, 0, 0, 5871, 5873, 3, 584, 292, 0, 5872, 5870, 1, 0, + 0, 0, 5872, 5873, 1, 0, 0, 0, 5873, 5875, 1, 0, 0, 0, 5874, 5876, 3, 496, + 248, 0, 5875, 5874, 1, 0, 0, 0, 5875, 5876, 1, 0, 0, 0, 5876, 5941, 1, + 0, 0, 0, 5877, 5878, 5, 155, 0, 0, 5878, 5879, 7, 81, 0, 0, 5879, 5880, + 5, 365, 0, 0, 5880, 5941, 3, 550, 275, 0, 5881, 5882, 5, 155, 0, 0, 5882, + 5885, 5, 441, 0, 0, 5883, 5884, 5, 65, 0, 0, 5884, 5886, 3, 564, 282, 0, + 5885, 5883, 1, 0, 0, 0, 5885, 5886, 1, 0, 0, 0, 5886, 5941, 1, 0, 0, 0, + 5887, 5888, 5, 155, 0, 0, 5888, 5889, 7, 82, 0, 0, 5889, 5890, 7, 77, 0, + 0, 5890, 5893, 3, 552, 276, 0, 5891, 5892, 7, 77, 0, 0, 5892, 5894, 3, + 584, 292, 0, 5893, 5891, 1, 0, 0, 0, 5893, 5894, 1, 0, 0, 0, 5894, 5897, + 1, 0, 0, 0, 5895, 5896, 5, 190, 0, 0, 5896, 5898, 3, 688, 344, 0, 5897, + 5895, 1, 0, 0, 0, 5897, 5898, 1, 0, 0, 0, 5898, 5941, 1, 0, 0, 0, 5899, + 5900, 5, 155, 0, 0, 5900, 5901, 5, 540, 0, 0, 5901, 5904, 5, 743, 0, 0, + 5902, 5903, 7, 77, 0, 0, 5903, 5905, 3, 584, 292, 0, 5904, 5902, 1, 0, + 0, 0, 5904, 5905, 1, 0, 0, 0, 5905, 5907, 1, 0, 0, 0, 5906, 5908, 3, 496, + 248, 0, 5907, 5906, 1, 0, 0, 0, 5907, 5908, 1, 0, 0, 0, 5908, 5941, 1, + 0, 0, 0, 5909, 5910, 5, 155, 0, 0, 5910, 5911, 5, 565, 0, 0, 5911, 5916, + 3, 502, 251, 0, 5912, 5913, 5, 1140, 0, 0, 5913, 5915, 3, 502, 251, 0, + 5914, 5912, 1, 0, 0, 0, 5915, 5918, 1, 0, 0, 0, 5916, 5914, 1, 0, 0, 0, + 5916, 5917, 1, 0, 0, 0, 5917, 5922, 1, 0, 0, 0, 5918, 5916, 1, 0, 0, 0, + 5919, 5920, 5, 65, 0, 0, 5920, 5921, 5, 568, 0, 0, 5921, 5923, 3, 590, + 295, 0, 5922, 5919, 1, 0, 0, 0, 5922, 5923, 1, 0, 0, 0, 5923, 5924, 1, + 0, 0, 0, 5924, 5928, 5, 99, 0, 0, 5925, 5926, 3, 590, 295, 0, 5926, 5927, + 5, 1140, 0, 0, 5927, 5929, 1, 0, 0, 0, 5928, 5925, 1, 0, 0, 0, 5928, 5929, + 1, 0, 0, 0, 5929, 5930, 1, 0, 0, 0, 5930, 5931, 3, 590, 295, 0, 5931, 5941, + 1, 0, 0, 0, 5932, 5933, 5, 155, 0, 0, 5933, 5934, 5, 615, 0, 0, 5934, 5938, + 5, 635, 0, 0, 5935, 5936, 5, 65, 0, 0, 5936, 5937, 5, 356, 0, 0, 5937, + 5939, 5, 1153, 0, 0, 5938, 5935, 1, 0, 0, 0, 5938, 5939, 1, 0, 0, 0, 5939, + 5941, 1, 0, 0, 0, 5940, 5787, 1, 0, 0, 0, 5940, 5790, 1, 0, 0, 0, 5940, + 5810, 1, 0, 0, 0, 5940, 5815, 1, 0, 0, 0, 5940, 5829, 1, 0, 0, 0, 5940, + 5836, 1, 0, 0, 0, 5940, 5840, 1, 0, 0, 0, 5940, 5844, 1, 0, 0, 0, 5940, + 5849, 1, 0, 0, 0, 5940, 5851, 1, 0, 0, 0, 5940, 5862, 1, 0, 0, 0, 5940, + 5868, 1, 0, 0, 0, 5940, 5877, 1, 0, 0, 0, 5940, 5881, 1, 0, 0, 0, 5940, + 5887, 1, 0, 0, 0, 5940, 5899, 1, 0, 0, 0, 5940, 5909, 1, 0, 0, 0, 5940, + 5932, 1, 0, 0, 0, 5941, 491, 1, 0, 0, 0, 5942, 5953, 5, 1164, 0, 0, 5943, + 5953, 5, 1165, 0, 0, 5944, 5945, 5, 1142, 0, 0, 5945, 5947, 5, 1142, 0, + 0, 5946, 5944, 1, 0, 0, 0, 5946, 5947, 1, 0, 0, 0, 5947, 5948, 1, 0, 0, + 0, 5948, 5950, 7, 83, 0, 0, 5949, 5946, 1, 0, 0, 0, 5949, 5950, 1, 0, 0, + 0, 5950, 5951, 1, 0, 0, 0, 5951, 5953, 3, 584, 292, 0, 5952, 5942, 1, 0, + 0, 0, 5952, 5943, 1, 0, 0, 0, 5952, 5949, 1, 0, 0, 0, 5953, 493, 1, 0, + 0, 0, 5954, 5955, 5, 25, 0, 0, 5955, 5968, 5, 153, 0, 0, 5956, 5968, 5, + 845, 0, 0, 5957, 5968, 5, 40, 0, 0, 5958, 5968, 5, 151, 0, 0, 5959, 5960, + 5, 438, 0, 0, 5960, 5968, 5, 635, 0, 0, 5961, 5962, 5, 131, 0, 0, 5962, + 5968, 5, 635, 0, 0, 5963, 5965, 7, 55, 0, 0, 5964, 5963, 1, 0, 0, 0, 5964, + 5965, 1, 0, 0, 0, 5965, 5966, 1, 0, 0, 0, 5966, 5968, 7, 84, 0, 0, 5967, + 5954, 1, 0, 0, 0, 5967, 5956, 1, 0, 0, 0, 5967, 5957, 1, 0, 0, 0, 5967, + 5958, 1, 0, 0, 0, 5967, 5959, 1, 0, 0, 0, 5967, 5961, 1, 0, 0, 0, 5967, + 5964, 1, 0, 0, 0, 5968, 495, 1, 0, 0, 0, 5969, 5970, 5, 98, 0, 0, 5970, + 5974, 5, 1153, 0, 0, 5971, 5972, 5, 190, 0, 0, 5972, 5974, 3, 688, 344, + 0, 5973, 5969, 1, 0, 0, 0, 5973, 5971, 1, 0, 0, 0, 5974, 497, 1, 0, 0, + 0, 5975, 5977, 5, 637, 0, 0, 5976, 5975, 1, 0, 0, 0, 5976, 5977, 1, 0, + 0, 0, 5977, 5978, 1, 0, 0, 0, 5978, 5993, 5, 411, 0, 0, 5979, 5980, 5, + 478, 0, 0, 5980, 5993, 5, 635, 0, 0, 5981, 5993, 5, 557, 0, 0, 5982, 5993, + 5, 726, 0, 0, 5983, 5985, 5, 437, 0, 0, 5984, 5983, 1, 0, 0, 0, 5984, 5985, + 1, 0, 0, 0, 5985, 5986, 1, 0, 0, 0, 5986, 5993, 5, 564, 0, 0, 5987, 5993, + 5, 566, 0, 0, 5988, 5989, 5, 615, 0, 0, 5989, 5993, 5, 448, 0, 0, 5990, + 5993, 5, 340, 0, 0, 5991, 5993, 5, 384, 0, 0, 5992, 5976, 1, 0, 0, 0, 5992, + 5979, 1, 0, 0, 0, 5992, 5981, 1, 0, 0, 0, 5992, 5982, 1, 0, 0, 0, 5992, + 5984, 1, 0, 0, 0, 5992, 5987, 1, 0, 0, 0, 5992, 5988, 1, 0, 0, 0, 5992, + 5990, 1, 0, 0, 0, 5992, 5991, 1, 0, 0, 0, 5993, 499, 1, 0, 0, 0, 5994, + 6003, 5, 417, 0, 0, 5995, 5996, 5, 172, 0, 0, 5996, 6003, 5, 635, 0, 0, + 5997, 5999, 5, 437, 0, 0, 5998, 5997, 1, 0, 0, 0, 5998, 5999, 1, 0, 0, + 0, 5999, 6000, 1, 0, 0, 0, 6000, 6003, 5, 743, 0, 0, 6001, 6003, 5, 656, + 0, 0, 6002, 5994, 1, 0, 0, 0, 6002, 5995, 1, 0, 0, 0, 6002, 5998, 1, 0, + 0, 0, 6002, 6001, 1, 0, 0, 0, 6003, 501, 1, 0, 0, 0, 6004, 6017, 5, 6, + 0, 0, 6005, 6006, 5, 348, 0, 0, 6006, 6017, 5, 462, 0, 0, 6007, 6008, 5, + 383, 0, 0, 6008, 6017, 5, 646, 0, 0, 6009, 6017, 5, 386, 0, 0, 6010, 6017, + 5, 464, 0, 0, 6011, 6017, 5, 793, 0, 0, 6012, 6013, 5, 545, 0, 0, 6013, + 6017, 5, 427, 0, 0, 6014, 6017, 5, 622, 0, 0, 6015, 6017, 5, 645, 0, 0, + 6016, 6004, 1, 0, 0, 0, 6016, 6005, 1, 0, 0, 0, 6016, 6007, 1, 0, 0, 0, + 6016, 6009, 1, 0, 0, 0, 6016, 6010, 1, 0, 0, 0, 6016, 6011, 1, 0, 0, 0, + 6016, 6012, 1, 0, 0, 0, 6016, 6014, 1, 0, 0, 0, 6016, 6015, 1, 0, 0, 0, + 6017, 503, 1, 0, 0, 0, 6018, 6019, 5, 346, 0, 0, 6019, 6020, 5, 1153, 0, + 0, 6020, 505, 1, 0, 0, 0, 6021, 6022, 5, 352, 0, 0, 6022, 6023, 5, 81, + 0, 0, 6023, 6028, 3, 518, 259, 0, 6024, 6025, 5, 1140, 0, 0, 6025, 6027, + 3, 518, 259, 0, 6026, 6024, 1, 0, 0, 0, 6027, 6030, 1, 0, 0, 0, 6028, 6026, + 1, 0, 0, 0, 6028, 6029, 1, 0, 0, 0, 6029, 6038, 1, 0, 0, 0, 6030, 6028, + 1, 0, 0, 0, 6031, 6032, 5, 129, 0, 0, 6032, 6035, 5, 1138, 0, 0, 6033, + 6036, 3, 616, 308, 0, 6034, 6036, 5, 6, 0, 0, 6035, 6033, 1, 0, 0, 0, 6035, + 6034, 1, 0, 0, 0, 6036, 6037, 1, 0, 0, 0, 6037, 6039, 5, 1139, 0, 0, 6038, + 6031, 1, 0, 0, 0, 6038, 6039, 1, 0, 0, 0, 6039, 6040, 1, 0, 0, 0, 6040, + 6041, 5, 80, 0, 0, 6041, 6042, 3, 584, 292, 0, 6042, 507, 1, 0, 0, 0, 6043, + 6045, 5, 433, 0, 0, 6044, 6046, 7, 72, 0, 0, 6045, 6044, 1, 0, 0, 0, 6045, + 6046, 1, 0, 0, 0, 6046, 6047, 1, 0, 0, 0, 6047, 6052, 3, 520, 260, 0, 6048, + 6049, 5, 1140, 0, 0, 6049, 6051, 3, 520, 260, 0, 6050, 6048, 1, 0, 0, 0, + 6051, 6054, 1, 0, 0, 0, 6052, 6050, 1, 0, 0, 0, 6052, 6053, 1, 0, 0, 0, + 6053, 509, 1, 0, 0, 0, 6054, 6052, 1, 0, 0, 0, 6055, 6057, 5, 93, 0, 0, + 6056, 6058, 7, 85, 0, 0, 6057, 6056, 1, 0, 0, 0, 6057, 6058, 1, 0, 0, 0, + 6058, 6059, 1, 0, 0, 0, 6059, 6060, 3, 688, 344, 0, 6060, 511, 1, 0, 0, + 0, 6061, 6062, 5, 102, 0, 0, 6062, 6063, 5, 81, 0, 0, 6063, 6064, 5, 87, + 0, 0, 6064, 6065, 5, 352, 0, 0, 6065, 6070, 3, 524, 262, 0, 6066, 6067, + 5, 1140, 0, 0, 6067, 6069, 3, 524, 262, 0, 6068, 6066, 1, 0, 0, 0, 6069, + 6072, 1, 0, 0, 0, 6070, 6068, 1, 0, 0, 0, 6070, 6071, 1, 0, 0, 0, 6071, + 513, 1, 0, 0, 0, 6072, 6070, 1, 0, 0, 0, 6073, 6074, 5, 590, 0, 0, 6074, + 6075, 5, 568, 0, 0, 6075, 6076, 5, 352, 0, 0, 6076, 515, 1, 0, 0, 0, 6077, + 6078, 5, 740, 0, 0, 6078, 517, 1, 0, 0, 0, 6079, 6087, 3, 552, 276, 0, + 6080, 6082, 7, 20, 0, 0, 6081, 6080, 1, 0, 0, 0, 6081, 6082, 1, 0, 0, 0, + 6082, 6083, 1, 0, 0, 0, 6083, 6084, 5, 1138, 0, 0, 6084, 6085, 3, 616, + 308, 0, 6085, 6086, 5, 1139, 0, 0, 6086, 6088, 1, 0, 0, 0, 6087, 6081, + 1, 0, 0, 0, 6087, 6088, 1, 0, 0, 0, 6088, 519, 1, 0, 0, 0, 6089, 6108, + 5, 395, 0, 0, 6090, 6108, 5, 448, 0, 0, 6091, 6093, 7, 86, 0, 0, 6092, + 6091, 1, 0, 0, 0, 6092, 6093, 1, 0, 0, 0, 6093, 6094, 1, 0, 0, 0, 6094, + 6108, 5, 477, 0, 0, 6095, 6108, 5, 541, 0, 0, 6096, 6108, 5, 726, 0, 0, + 6097, 6098, 5, 568, 0, 0, 6098, 6108, 5, 352, 0, 0, 6099, 6108, 5, 635, + 0, 0, 6100, 6108, 5, 668, 0, 0, 6101, 6105, 5, 743, 0, 0, 6102, 6103, 5, + 192, 0, 0, 6103, 6104, 5, 134, 0, 0, 6104, 6106, 5, 103, 0, 0, 6105, 6102, + 1, 0, 0, 0, 6105, 6106, 1, 0, 0, 0, 6106, 6108, 1, 0, 0, 0, 6107, 6089, + 1, 0, 0, 0, 6107, 6090, 1, 0, 0, 0, 6107, 6092, 1, 0, 0, 0, 6107, 6095, + 1, 0, 0, 0, 6107, 6096, 1, 0, 0, 0, 6107, 6097, 1, 0, 0, 0, 6107, 6099, + 1, 0, 0, 0, 6107, 6100, 1, 0, 0, 0, 6107, 6101, 1, 0, 0, 0, 6108, 6122, + 1, 0, 0, 0, 6109, 6110, 5, 575, 0, 0, 6110, 6112, 5, 477, 0, 0, 6111, 6113, + 3, 356, 178, 0, 6112, 6111, 1, 0, 0, 0, 6112, 6113, 1, 0, 0, 0, 6113, 6122, + 1, 0, 0, 0, 6114, 6116, 7, 54, 0, 0, 6115, 6117, 3, 620, 310, 0, 6116, + 6115, 1, 0, 0, 0, 6116, 6117, 1, 0, 0, 0, 6117, 6119, 1, 0, 0, 0, 6118, + 6120, 3, 522, 261, 0, 6119, 6118, 1, 0, 0, 0, 6119, 6120, 1, 0, 0, 0, 6120, + 6122, 1, 0, 0, 0, 6121, 6107, 1, 0, 0, 0, 6121, 6109, 1, 0, 0, 0, 6121, + 6114, 1, 0, 0, 0, 6122, 521, 1, 0, 0, 0, 6123, 6124, 5, 192, 0, 0, 6124, + 6125, 5, 134, 0, 0, 6125, 6129, 5, 103, 0, 0, 6126, 6127, 5, 65, 0, 0, + 6127, 6129, 5, 422, 0, 0, 6128, 6123, 1, 0, 0, 0, 6128, 6126, 1, 0, 0, + 0, 6129, 523, 1, 0, 0, 0, 6130, 6138, 3, 552, 276, 0, 6131, 6132, 5, 129, + 0, 0, 6132, 6135, 5, 1138, 0, 0, 6133, 6136, 3, 616, 308, 0, 6134, 6136, + 5, 6, 0, 0, 6135, 6133, 1, 0, 0, 0, 6135, 6134, 1, 0, 0, 0, 6136, 6137, + 1, 0, 0, 0, 6137, 6139, 5, 1139, 0, 0, 6138, 6131, 1, 0, 0, 0, 6138, 6139, + 1, 0, 0, 0, 6139, 6147, 1, 0, 0, 0, 6140, 6142, 7, 20, 0, 0, 6141, 6140, + 1, 0, 0, 0, 6141, 6142, 1, 0, 0, 0, 6142, 6143, 1, 0, 0, 0, 6143, 6144, + 5, 1138, 0, 0, 6144, 6145, 3, 616, 308, 0, 6145, 6146, 5, 1139, 0, 0, 6146, + 6148, 1, 0, 0, 0, 6147, 6141, 1, 0, 0, 0, 6147, 6148, 1, 0, 0, 0, 6148, + 6151, 1, 0, 0, 0, 6149, 6150, 5, 78, 0, 0, 6150, 6152, 5, 471, 0, 0, 6151, + 6149, 1, 0, 0, 0, 6151, 6152, 1, 0, 0, 0, 6152, 525, 1, 0, 0, 0, 6153, + 6154, 7, 87, 0, 0, 6154, 6157, 3, 552, 276, 0, 6155, 6158, 3, 584, 292, + 0, 6156, 6158, 5, 1153, 0, 0, 6157, 6155, 1, 0, 0, 0, 6157, 6156, 1, 0, + 0, 0, 6157, 6158, 1, 0, 0, 0, 6158, 527, 1, 0, 0, 0, 6159, 6163, 7, 87, + 0, 0, 6160, 6161, 7, 88, 0, 0, 6161, 6162, 5, 1129, 0, 0, 6162, 6164, 7, + 89, 0, 0, 6163, 6160, 1, 0, 0, 0, 6163, 6164, 1, 0, 0, 0, 6164, 6165, 1, + 0, 0, 0, 6165, 6166, 3, 548, 274, 0, 6166, 529, 1, 0, 0, 0, 6167, 6168, + 5, 445, 0, 0, 6168, 6169, 5, 1153, 0, 0, 6169, 531, 1, 0, 0, 0, 6170, 6171, + 5, 186, 0, 0, 6171, 6172, 3, 584, 292, 0, 6172, 533, 1, 0, 0, 0, 6173, + 6181, 5, 156, 0, 0, 6174, 6176, 5, 162, 0, 0, 6175, 6177, 5, 670, 0, 0, + 6176, 6175, 1, 0, 0, 0, 6176, 6177, 1, 0, 0, 0, 6177, 6178, 1, 0, 0, 0, + 6178, 6182, 3, 594, 297, 0, 6179, 6182, 5, 1161, 0, 0, 6180, 6182, 5, 1162, + 0, 0, 6181, 6174, 1, 0, 0, 0, 6181, 6179, 1, 0, 0, 0, 6181, 6180, 1, 0, + 0, 0, 6182, 6192, 1, 0, 0, 0, 6183, 6184, 5, 153, 0, 0, 6184, 6189, 3, + 538, 269, 0, 6185, 6186, 5, 1140, 0, 0, 6186, 6188, 3, 538, 269, 0, 6187, + 6185, 1, 0, 0, 0, 6188, 6191, 1, 0, 0, 0, 6189, 6187, 1, 0, 0, 0, 6189, + 6190, 1, 0, 0, 0, 6190, 6193, 1, 0, 0, 0, 6191, 6189, 1, 0, 0, 0, 6192, + 6183, 1, 0, 0, 0, 6192, 6193, 1, 0, 0, 0, 6193, 535, 1, 0, 0, 0, 6194, + 6202, 5, 143, 0, 0, 6195, 6197, 5, 162, 0, 0, 6196, 6198, 5, 670, 0, 0, + 6197, 6196, 1, 0, 0, 0, 6197, 6198, 1, 0, 0, 0, 6198, 6199, 1, 0, 0, 0, + 6199, 6203, 3, 594, 297, 0, 6200, 6203, 5, 1161, 0, 0, 6201, 6203, 5, 1162, + 0, 0, 6202, 6195, 1, 0, 0, 0, 6202, 6200, 1, 0, 0, 0, 6202, 6201, 1, 0, + 0, 0, 6202, 6203, 1, 0, 0, 0, 6203, 6213, 1, 0, 0, 0, 6204, 6205, 5, 153, + 0, 0, 6205, 6210, 3, 538, 269, 0, 6206, 6207, 5, 1140, 0, 0, 6207, 6209, + 3, 538, 269, 0, 6208, 6206, 1, 0, 0, 0, 6209, 6212, 1, 0, 0, 0, 6210, 6208, + 1, 0, 0, 0, 6210, 6211, 1, 0, 0, 0, 6211, 6214, 1, 0, 0, 0, 6212, 6210, + 1, 0, 0, 0, 6213, 6204, 1, 0, 0, 0, 6213, 6214, 1, 0, 0, 0, 6214, 537, + 1, 0, 0, 0, 6215, 6216, 7, 90, 0, 0, 6216, 6221, 5, 1129, 0, 0, 6217, 6222, + 3, 594, 297, 0, 6218, 6222, 5, 1154, 0, 0, 6219, 6222, 3, 566, 283, 0, + 6220, 6222, 3, 586, 293, 0, 6221, 6217, 1, 0, 0, 0, 6221, 6218, 1, 0, 0, + 0, 6221, 6219, 1, 0, 0, 0, 6221, 6220, 1, 0, 0, 0, 6222, 539, 1, 0, 0, + 0, 6223, 6225, 5, 192, 0, 0, 6224, 6226, 5, 572, 0, 0, 6225, 6224, 1, 0, + 0, 0, 6225, 6226, 1, 0, 0, 0, 6226, 6227, 1, 0, 0, 0, 6227, 6232, 3, 50, + 25, 0, 6228, 6229, 5, 1140, 0, 0, 6229, 6231, 3, 50, 25, 0, 6230, 6228, + 1, 0, 0, 0, 6231, 6234, 1, 0, 0, 0, 6232, 6230, 1, 0, 0, 0, 6232, 6233, + 1, 0, 0, 0, 6233, 541, 1, 0, 0, 0, 6234, 6232, 1, 0, 0, 0, 6235, 6236, + 5, 172, 0, 0, 6236, 6238, 3, 552, 276, 0, 6237, 6239, 3, 230, 115, 0, 6238, + 6237, 1, 0, 0, 0, 6238, 6239, 1, 0, 0, 0, 6239, 6241, 1, 0, 0, 0, 6240, + 6242, 3, 294, 147, 0, 6241, 6240, 1, 0, 0, 0, 6241, 6242, 1, 0, 0, 0, 6242, + 543, 1, 0, 0, 0, 6243, 6245, 5, 71, 0, 0, 6244, 6246, 7, 91, 0, 0, 6245, + 6244, 1, 0, 0, 0, 6245, 6246, 1, 0, 0, 0, 6246, 6247, 1, 0, 0, 0, 6247, + 6279, 5, 48, 0, 0, 6248, 6249, 3, 492, 246, 0, 6249, 6250, 5, 1129, 0, + 0, 6250, 6258, 7, 92, 0, 0, 6251, 6252, 5, 1140, 0, 0, 6252, 6253, 3, 492, + 246, 0, 6253, 6254, 5, 1129, 0, 0, 6254, 6255, 7, 92, 0, 0, 6255, 6257, + 1, 0, 0, 0, 6256, 6251, 1, 0, 0, 0, 6257, 6260, 1, 0, 0, 0, 6258, 6256, + 1, 0, 0, 0, 6258, 6259, 1, 0, 0, 0, 6259, 6280, 1, 0, 0, 0, 6260, 6258, + 1, 0, 0, 0, 6261, 6264, 5, 29, 0, 0, 6262, 6265, 3, 590, 295, 0, 6263, + 6265, 3, 492, 246, 0, 6264, 6262, 1, 0, 0, 0, 6264, 6263, 1, 0, 0, 0, 6265, + 6266, 1, 0, 0, 0, 6266, 6267, 3, 492, 246, 0, 6267, 6268, 5, 1129, 0, 0, + 6268, 6276, 3, 546, 273, 0, 6269, 6270, 5, 1140, 0, 0, 6270, 6271, 3, 492, + 246, 0, 6271, 6272, 5, 1129, 0, 0, 6272, 6273, 3, 546, 273, 0, 6273, 6275, + 1, 0, 0, 0, 6274, 6269, 1, 0, 0, 0, 6275, 6278, 1, 0, 0, 0, 6276, 6274, + 1, 0, 0, 0, 6276, 6277, 1, 0, 0, 0, 6277, 6280, 1, 0, 0, 0, 6278, 6276, + 1, 0, 0, 0, 6279, 6248, 1, 0, 0, 0, 6279, 6261, 1, 0, 0, 0, 6280, 545, + 1, 0, 0, 0, 6281, 6282, 7, 93, 0, 0, 6282, 547, 1, 0, 0, 0, 6283, 6289, + 3, 200, 100, 0, 6284, 6289, 3, 186, 93, 0, 6285, 6289, 3, 192, 96, 0, 6286, + 6289, 3, 198, 99, 0, 6287, 6289, 3, 202, 101, 0, 6288, 6283, 1, 0, 0, 0, + 6288, 6284, 1, 0, 0, 0, 6288, 6285, 1, 0, 0, 0, 6288, 6286, 1, 0, 0, 0, + 6288, 6287, 1, 0, 0, 0, 6289, 6294, 1, 0, 0, 0, 6290, 6291, 5, 65, 0, 0, + 6291, 6292, 5, 377, 0, 0, 6292, 6294, 3, 584, 292, 0, 6293, 6288, 1, 0, + 0, 0, 6293, 6290, 1, 0, 0, 0, 6294, 549, 1, 0, 0, 0, 6295, 6299, 3, 584, + 292, 0, 6296, 6300, 5, 1160, 0, 0, 6297, 6298, 5, 1137, 0, 0, 6298, 6300, + 3, 584, 292, 0, 6299, 6296, 1, 0, 0, 0, 6299, 6297, 1, 0, 0, 0, 6299, 6300, + 1, 0, 0, 0, 6300, 551, 1, 0, 0, 0, 6301, 6302, 3, 550, 275, 0, 6302, 553, + 1, 0, 0, 0, 6303, 6306, 3, 564, 282, 0, 6304, 6306, 3, 584, 292, 0, 6305, + 6303, 1, 0, 0, 0, 6305, 6304, 1, 0, 0, 0, 6306, 555, 1, 0, 0, 0, 6307, + 6312, 3, 584, 292, 0, 6308, 6310, 3, 588, 294, 0, 6309, 6311, 3, 588, 294, + 0, 6310, 6309, 1, 0, 0, 0, 6310, 6311, 1, 0, 0, 0, 6311, 6313, 1, 0, 0, + 0, 6312, 6308, 1, 0, 0, 0, 6312, 6313, 1, 0, 0, 0, 6313, 6322, 1, 0, 0, + 0, 6314, 6316, 9, 0, 0, 0, 6315, 6314, 1, 0, 0, 0, 6315, 6316, 1, 0, 0, + 0, 6316, 6317, 1, 0, 0, 0, 6317, 6319, 3, 588, 294, 0, 6318, 6320, 3, 588, + 294, 0, 6319, 6318, 1, 0, 0, 0, 6319, 6320, 1, 0, 0, 0, 6320, 6322, 1, + 0, 0, 0, 6321, 6307, 1, 0, 0, 0, 6321, 6315, 1, 0, 0, 0, 6322, 557, 1, + 0, 0, 0, 6323, 6326, 3, 584, 292, 0, 6324, 6326, 5, 1153, 0, 0, 6325, 6323, + 1, 0, 0, 0, 6325, 6324, 1, 0, 0, 0, 6326, 6331, 1, 0, 0, 0, 6327, 6328, + 5, 1138, 0, 0, 6328, 6329, 3, 590, 295, 0, 6329, 6330, 5, 1139, 0, 0, 6330, + 6332, 1, 0, 0, 0, 6331, 6327, 1, 0, 0, 0, 6331, 6332, 1, 0, 0, 0, 6332, + 6335, 1, 0, 0, 0, 6333, 6335, 3, 688, 344, 0, 6334, 6325, 1, 0, 0, 0, 6334, + 6333, 1, 0, 0, 0, 6335, 6337, 1, 0, 0, 0, 6336, 6338, 7, 48, 0, 0, 6337, + 6336, 1, 0, 0, 0, 6337, 6338, 1, 0, 0, 0, 6338, 559, 1, 0, 0, 0, 6339, + 6344, 5, 1153, 0, 0, 6340, 6344, 5, 1161, 0, 0, 6341, 6344, 5, 698, 0, + 0, 6342, 6344, 3, 718, 359, 0, 6343, 6339, 1, 0, 0, 0, 6343, 6340, 1, 0, + 0, 0, 6343, 6341, 1, 0, 0, 0, 6343, 6342, 1, 0, 0, 0, 6344, 561, 1, 0, + 0, 0, 6345, 6346, 7, 94, 0, 0, 6346, 563, 1, 0, 0, 0, 6347, 6353, 3, 560, + 280, 0, 6348, 6349, 3, 560, 280, 0, 6349, 6350, 3, 562, 281, 0, 6350, 6353, + 1, 0, 0, 0, 6351, 6353, 3, 62, 31, 0, 6352, 6347, 1, 0, 0, 0, 6352, 6348, + 1, 0, 0, 0, 6352, 6351, 1, 0, 0, 0, 6353, 565, 1, 0, 0, 0, 6354, 6355, + 7, 95, 0, 0, 6355, 567, 1, 0, 0, 0, 6356, 6361, 5, 226, 0, 0, 6357, 6361, + 3, 708, 354, 0, 6358, 6361, 5, 1153, 0, 0, 6359, 6361, 5, 1150, 0, 0, 6360, + 6356, 1, 0, 0, 0, 6360, 6357, 1, 0, 0, 0, 6360, 6358, 1, 0, 0, 0, 6360, + 6359, 1, 0, 0, 0, 6361, 569, 1, 0, 0, 0, 6362, 6365, 3, 584, 292, 0, 6363, + 6365, 5, 1153, 0, 0, 6364, 6362, 1, 0, 0, 0, 6364, 6363, 1, 0, 0, 0, 6365, + 571, 1, 0, 0, 0, 6366, 6370, 3, 574, 287, 0, 6367, 6370, 5, 1161, 0, 0, + 6368, 6370, 5, 1153, 0, 0, 6369, 6366, 1, 0, 0, 0, 6369, 6367, 1, 0, 0, + 0, 6369, 6368, 1, 0, 0, 0, 6370, 573, 1, 0, 0, 0, 6371, 6372, 7, 96, 0, + 0, 6372, 575, 1, 0, 0, 0, 6373, 6374, 3, 590, 295, 0, 6374, 6375, 5, 1126, + 0, 0, 6375, 6376, 3, 590, 295, 0, 6376, 6377, 5, 1126, 0, 0, 6377, 6378, + 3, 590, 295, 0, 6378, 6379, 5, 1126, 0, 0, 6379, 6380, 3, 590, 295, 0, + 6380, 6381, 5, 1126, 0, 0, 6381, 6387, 3, 590, 295, 0, 6382, 6383, 5, 1149, + 0, 0, 6383, 6384, 3, 590, 295, 0, 6384, 6385, 5, 1126, 0, 0, 6385, 6386, + 3, 590, 295, 0, 6386, 6388, 1, 0, 0, 0, 6387, 6382, 1, 0, 0, 0, 6388, 6389, + 1, 0, 0, 0, 6389, 6387, 1, 0, 0, 0, 6389, 6390, 1, 0, 0, 0, 6390, 577, + 1, 0, 0, 0, 6391, 6398, 3, 580, 290, 0, 6392, 6393, 5, 1140, 0, 0, 6393, + 6396, 3, 580, 290, 0, 6394, 6395, 5, 1140, 0, 0, 6395, 6397, 3, 590, 295, + 0, 6396, 6394, 1, 0, 0, 0, 6396, 6397, 1, 0, 0, 0, 6397, 6399, 1, 0, 0, + 0, 6398, 6392, 1, 0, 0, 0, 6398, 6399, 1, 0, 0, 0, 6399, 579, 1, 0, 0, + 0, 6400, 6408, 5, 1153, 0, 0, 6401, 6408, 5, 1158, 0, 0, 6402, 6404, 5, + 1155, 0, 0, 6403, 6402, 1, 0, 0, 0, 6404, 6405, 1, 0, 0, 0, 6405, 6403, + 1, 0, 0, 0, 6405, 6406, 1, 0, 0, 0, 6406, 6408, 1, 0, 0, 0, 6407, 6400, + 1, 0, 0, 0, 6407, 6401, 1, 0, 0, 0, 6407, 6403, 1, 0, 0, 0, 6408, 581, + 1, 0, 0, 0, 6409, 6412, 3, 584, 292, 0, 6410, 6412, 5, 1153, 0, 0, 6411, + 6409, 1, 0, 0, 0, 6411, 6410, 1, 0, 0, 0, 6412, 583, 1, 0, 0, 0, 6413, + 6417, 3, 586, 293, 0, 6414, 6417, 5, 1150, 0, 0, 6415, 6417, 5, 1153, 0, + 0, 6416, 6413, 1, 0, 0, 0, 6416, 6414, 1, 0, 0, 0, 6416, 6415, 1, 0, 0, + 0, 6417, 585, 1, 0, 0, 0, 6418, 6428, 5, 1161, 0, 0, 6419, 6428, 3, 708, + 354, 0, 6420, 6428, 3, 710, 355, 0, 6421, 6428, 3, 574, 287, 0, 6422, 6428, + 3, 712, 356, 0, 6423, 6428, 3, 714, 357, 0, 6424, 6428, 3, 716, 358, 0, + 6425, 6428, 3, 718, 359, 0, 6426, 6428, 3, 680, 340, 0, 6427, 6418, 1, + 0, 0, 0, 6427, 6419, 1, 0, 0, 0, 6427, 6420, 1, 0, 0, 0, 6427, 6421, 1, + 0, 0, 0, 6427, 6422, 1, 0, 0, 0, 6427, 6423, 1, 0, 0, 0, 6427, 6424, 1, + 0, 0, 0, 6427, 6425, 1, 0, 0, 0, 6427, 6426, 1, 0, 0, 0, 6428, 587, 1, + 0, 0, 0, 6429, 6433, 5, 1160, 0, 0, 6430, 6431, 5, 1137, 0, 0, 6431, 6433, + 3, 584, 292, 0, 6432, 6429, 1, 0, 0, 0, 6432, 6430, 1, 0, 0, 0, 6433, 589, + 1, 0, 0, 0, 6434, 6435, 7, 97, 0, 0, 6435, 591, 1, 0, 0, 0, 6436, 6439, + 5, 1151, 0, 0, 6437, 6439, 3, 590, 295, 0, 6438, 6436, 1, 0, 0, 0, 6438, + 6437, 1, 0, 0, 0, 6439, 593, 1, 0, 0, 0, 6440, 6442, 5, 1159, 0, 0, 6441, + 6440, 1, 0, 0, 0, 6441, 6442, 1, 0, 0, 0, 6442, 6443, 1, 0, 0, 0, 6443, + 6446, 5, 1153, 0, 0, 6444, 6446, 5, 1152, 0, 0, 6445, 6441, 1, 0, 0, 0, + 6445, 6444, 1, 0, 0, 0, 6446, 6448, 1, 0, 0, 0, 6447, 6449, 5, 1153, 0, + 0, 6448, 6447, 1, 0, 0, 0, 6449, 6450, 1, 0, 0, 0, 6450, 6448, 1, 0, 0, + 0, 6450, 6451, 1, 0, 0, 0, 6451, 6464, 1, 0, 0, 0, 6452, 6454, 5, 1159, + 0, 0, 6453, 6452, 1, 0, 0, 0, 6453, 6454, 1, 0, 0, 0, 6454, 6455, 1, 0, + 0, 0, 6455, 6458, 5, 1153, 0, 0, 6456, 6458, 5, 1152, 0, 0, 6457, 6453, + 1, 0, 0, 0, 6457, 6456, 1, 0, 0, 0, 6458, 6461, 1, 0, 0, 0, 6459, 6460, + 5, 27, 0, 0, 6460, 6462, 3, 570, 285, 0, 6461, 6459, 1, 0, 0, 0, 6461, + 6462, 1, 0, 0, 0, 6462, 6464, 1, 0, 0, 0, 6463, 6445, 1, 0, 0, 0, 6463, + 6457, 1, 0, 0, 0, 6464, 595, 1, 0, 0, 0, 6465, 6466, 7, 98, 0, 0, 6466, + 597, 1, 0, 0, 0, 6467, 6469, 5, 1159, 0, 0, 6468, 6467, 1, 0, 0, 0, 6468, + 6469, 1, 0, 0, 0, 6469, 6470, 1, 0, 0, 0, 6470, 6471, 5, 1155, 0, 0, 6471, + 599, 1, 0, 0, 0, 6472, 6474, 5, 114, 0, 0, 6473, 6472, 1, 0, 0, 0, 6473, + 6474, 1, 0, 0, 0, 6474, 6475, 1, 0, 0, 0, 6475, 6476, 7, 99, 0, 0, 6476, + 601, 1, 0, 0, 0, 6477, 6490, 3, 594, 297, 0, 6478, 6490, 3, 590, 295, 0, + 6479, 6480, 5, 1126, 0, 0, 6480, 6490, 3, 590, 295, 0, 6481, 6490, 3, 598, + 299, 0, 6482, 6490, 3, 596, 298, 0, 6483, 6490, 5, 1156, 0, 0, 6484, 6490, + 5, 1158, 0, 0, 6485, 6487, 5, 114, 0, 0, 6486, 6485, 1, 0, 0, 0, 6486, + 6487, 1, 0, 0, 0, 6487, 6488, 1, 0, 0, 0, 6488, 6490, 7, 99, 0, 0, 6489, + 6477, 1, 0, 0, 0, 6489, 6478, 1, 0, 0, 0, 6489, 6479, 1, 0, 0, 0, 6489, + 6481, 1, 0, 0, 0, 6489, 6482, 1, 0, 0, 0, 6489, 6483, 1, 0, 0, 0, 6489, + 6484, 1, 0, 0, 0, 6489, 6486, 1, 0, 0, 0, 6490, 603, 1, 0, 0, 0, 6491, + 6493, 7, 100, 0, 0, 6492, 6494, 5, 238, 0, 0, 6493, 6492, 1, 0, 0, 0, 6493, + 6494, 1, 0, 0, 0, 6494, 6496, 1, 0, 0, 0, 6495, 6497, 3, 610, 305, 0, 6496, + 6495, 1, 0, 0, 0, 6496, 6497, 1, 0, 0, 0, 6497, 6499, 1, 0, 0, 0, 6498, + 6500, 5, 226, 0, 0, 6499, 6498, 1, 0, 0, 0, 6499, 6500, 1, 0, 0, 0, 6500, + 6504, 1, 0, 0, 0, 6501, 6502, 3, 60, 30, 0, 6502, 6503, 3, 568, 284, 0, + 6503, 6505, 1, 0, 0, 0, 6504, 6501, 1, 0, 0, 0, 6504, 6505, 1, 0, 0, 0, + 6505, 6509, 1, 0, 0, 0, 6506, 6507, 5, 27, 0, 0, 6507, 6510, 3, 570, 285, + 0, 6508, 6510, 5, 226, 0, 0, 6509, 6506, 1, 0, 0, 0, 6509, 6508, 1, 0, + 0, 0, 6509, 6510, 1, 0, 0, 0, 6510, 6618, 1, 0, 0, 0, 6511, 6512, 5, 225, + 0, 0, 6512, 6513, 7, 101, 0, 0, 6513, 6515, 5, 238, 0, 0, 6514, 6516, 3, + 610, 305, 0, 6515, 6514, 1, 0, 0, 0, 6515, 6516, 1, 0, 0, 0, 6516, 6518, + 1, 0, 0, 0, 6517, 6519, 5, 226, 0, 0, 6518, 6517, 1, 0, 0, 0, 6518, 6519, + 1, 0, 0, 0, 6519, 6618, 1, 0, 0, 0, 6520, 6521, 5, 225, 0, 0, 6521, 6523, + 7, 102, 0, 0, 6522, 6524, 3, 610, 305, 0, 6523, 6522, 1, 0, 0, 0, 6523, + 6524, 1, 0, 0, 0, 6524, 6526, 1, 0, 0, 0, 6525, 6527, 5, 226, 0, 0, 6526, + 6525, 1, 0, 0, 0, 6526, 6527, 1, 0, 0, 0, 6527, 6618, 1, 0, 0, 0, 6528, + 6529, 5, 519, 0, 0, 6529, 6531, 5, 223, 0, 0, 6530, 6532, 3, 610, 305, + 0, 6531, 6530, 1, 0, 0, 0, 6531, 6532, 1, 0, 0, 0, 6532, 6534, 1, 0, 0, + 0, 6533, 6535, 5, 226, 0, 0, 6534, 6533, 1, 0, 0, 0, 6534, 6535, 1, 0, + 0, 0, 6535, 6618, 1, 0, 0, 0, 6536, 6538, 7, 103, 0, 0, 6537, 6539, 3, + 610, 305, 0, 6538, 6537, 1, 0, 0, 0, 6538, 6539, 1, 0, 0, 0, 6539, 6543, + 1, 0, 0, 0, 6540, 6542, 7, 104, 0, 0, 6541, 6540, 1, 0, 0, 0, 6542, 6545, + 1, 0, 0, 0, 6543, 6541, 1, 0, 0, 0, 6543, 6544, 1, 0, 0, 0, 6544, 6618, + 1, 0, 0, 0, 6545, 6543, 1, 0, 0, 0, 6546, 6548, 5, 208, 0, 0, 6547, 6549, + 3, 612, 306, 0, 6548, 6547, 1, 0, 0, 0, 6548, 6549, 1, 0, 0, 0, 6549, 6553, + 1, 0, 0, 0, 6550, 6552, 7, 104, 0, 0, 6551, 6550, 1, 0, 0, 0, 6552, 6555, + 1, 0, 0, 0, 6553, 6551, 1, 0, 0, 0, 6553, 6554, 1, 0, 0, 0, 6554, 6618, + 1, 0, 0, 0, 6555, 6553, 1, 0, 0, 0, 6556, 6558, 5, 209, 0, 0, 6557, 6559, + 5, 210, 0, 0, 6558, 6557, 1, 0, 0, 0, 6558, 6559, 1, 0, 0, 0, 6559, 6561, + 1, 0, 0, 0, 6560, 6562, 3, 612, 306, 0, 6561, 6560, 1, 0, 0, 0, 6561, 6562, + 1, 0, 0, 0, 6562, 6566, 1, 0, 0, 0, 6563, 6565, 7, 104, 0, 0, 6564, 6563, + 1, 0, 0, 0, 6565, 6568, 1, 0, 0, 0, 6566, 6564, 1, 0, 0, 0, 6566, 6567, + 1, 0, 0, 0, 6567, 6618, 1, 0, 0, 0, 6568, 6566, 1, 0, 0, 0, 6569, 6571, + 7, 105, 0, 0, 6570, 6572, 3, 614, 307, 0, 6571, 6570, 1, 0, 0, 0, 6571, + 6572, 1, 0, 0, 0, 6572, 6576, 1, 0, 0, 0, 6573, 6575, 7, 104, 0, 0, 6574, + 6573, 1, 0, 0, 0, 6575, 6578, 1, 0, 0, 0, 6576, 6574, 1, 0, 0, 0, 6576, + 6577, 1, 0, 0, 0, 6577, 6618, 1, 0, 0, 0, 6578, 6576, 1, 0, 0, 0, 6579, + 6618, 7, 106, 0, 0, 6580, 6582, 7, 107, 0, 0, 6581, 6583, 3, 610, 305, + 0, 6582, 6581, 1, 0, 0, 0, 6582, 6583, 1, 0, 0, 0, 6583, 6618, 1, 0, 0, + 0, 6584, 6585, 7, 108, 0, 0, 6585, 6587, 3, 606, 303, 0, 6586, 6588, 5, + 226, 0, 0, 6587, 6586, 1, 0, 0, 0, 6587, 6588, 1, 0, 0, 0, 6588, 6592, + 1, 0, 0, 0, 6589, 6590, 3, 60, 30, 0, 6590, 6591, 3, 568, 284, 0, 6591, + 6593, 1, 0, 0, 0, 6592, 6589, 1, 0, 0, 0, 6592, 6593, 1, 0, 0, 0, 6593, + 6618, 1, 0, 0, 0, 6594, 6597, 7, 109, 0, 0, 6595, 6596, 5, 1014, 0, 0, + 6596, 6598, 3, 590, 295, 0, 6597, 6595, 1, 0, 0, 0, 6597, 6598, 1, 0, 0, + 0, 6598, 6618, 1, 0, 0, 0, 6599, 6601, 5, 231, 0, 0, 6600, 6602, 5, 223, + 0, 0, 6601, 6600, 1, 0, 0, 0, 6601, 6602, 1, 0, 0, 0, 6602, 6604, 1, 0, + 0, 0, 6603, 6605, 5, 226, 0, 0, 6604, 6603, 1, 0, 0, 0, 6604, 6605, 1, + 0, 0, 0, 6605, 6609, 1, 0, 0, 0, 6606, 6607, 3, 60, 30, 0, 6607, 6608, + 3, 568, 284, 0, 6608, 6610, 1, 0, 0, 0, 6609, 6606, 1, 0, 0, 0, 6609, 6610, + 1, 0, 0, 0, 6610, 6613, 1, 0, 0, 0, 6611, 6612, 5, 27, 0, 0, 6612, 6614, + 3, 570, 285, 0, 6613, 6611, 1, 0, 0, 0, 6613, 6614, 1, 0, 0, 0, 6614, 6618, + 1, 0, 0, 0, 6615, 6616, 5, 231, 0, 0, 6616, 6618, 5, 227, 0, 0, 6617, 6491, + 1, 0, 0, 0, 6617, 6511, 1, 0, 0, 0, 6617, 6520, 1, 0, 0, 0, 6617, 6528, + 1, 0, 0, 0, 6617, 6536, 1, 0, 0, 0, 6617, 6546, 1, 0, 0, 0, 6617, 6556, + 1, 0, 0, 0, 6617, 6569, 1, 0, 0, 0, 6617, 6579, 1, 0, 0, 0, 6617, 6580, + 1, 0, 0, 0, 6617, 6584, 1, 0, 0, 0, 6617, 6594, 1, 0, 0, 0, 6617, 6599, + 1, 0, 0, 0, 6617, 6615, 1, 0, 0, 0, 6618, 605, 1, 0, 0, 0, 6619, 6620, + 5, 1138, 0, 0, 6620, 6625, 5, 1153, 0, 0, 6621, 6622, 5, 1140, 0, 0, 6622, + 6624, 5, 1153, 0, 0, 6623, 6621, 1, 0, 0, 0, 6624, 6627, 1, 0, 0, 0, 6625, + 6623, 1, 0, 0, 0, 6625, 6626, 1, 0, 0, 0, 6626, 6628, 1, 0, 0, 0, 6627, + 6625, 1, 0, 0, 0, 6628, 6629, 5, 1139, 0, 0, 6629, 607, 1, 0, 0, 0, 6630, + 6632, 7, 110, 0, 0, 6631, 6633, 3, 610, 305, 0, 6632, 6631, 1, 0, 0, 0, + 6632, 6633, 1, 0, 0, 0, 6633, 6653, 1, 0, 0, 0, 6634, 6636, 5, 222, 0, + 0, 6635, 6637, 3, 610, 305, 0, 6636, 6635, 1, 0, 0, 0, 6636, 6637, 1, 0, + 0, 0, 6637, 6641, 1, 0, 0, 0, 6638, 6639, 3, 60, 30, 0, 6639, 6640, 3, + 568, 284, 0, 6640, 6642, 1, 0, 0, 0, 6641, 6638, 1, 0, 0, 0, 6641, 6642, + 1, 0, 0, 0, 6642, 6653, 1, 0, 0, 0, 6643, 6653, 7, 111, 0, 0, 6644, 6646, + 7, 112, 0, 0, 6645, 6647, 3, 614, 307, 0, 6646, 6645, 1, 0, 0, 0, 6646, + 6647, 1, 0, 0, 0, 6647, 6653, 1, 0, 0, 0, 6648, 6650, 7, 113, 0, 0, 6649, + 6651, 7, 114, 0, 0, 6650, 6649, 1, 0, 0, 0, 6650, 6651, 1, 0, 0, 0, 6651, + 6653, 1, 0, 0, 0, 6652, 6630, 1, 0, 0, 0, 6652, 6634, 1, 0, 0, 0, 6652, + 6643, 1, 0, 0, 0, 6652, 6644, 1, 0, 0, 0, 6652, 6648, 1, 0, 0, 0, 6653, + 6655, 1, 0, 0, 0, 6654, 6656, 5, 11, 0, 0, 6655, 6654, 1, 0, 0, 0, 6655, + 6656, 1, 0, 0, 0, 6656, 609, 1, 0, 0, 0, 6657, 6658, 5, 1138, 0, 0, 6658, + 6659, 3, 590, 295, 0, 6659, 6660, 5, 1139, 0, 0, 6660, 611, 1, 0, 0, 0, + 6661, 6662, 5, 1138, 0, 0, 6662, 6663, 3, 590, 295, 0, 6663, 6664, 5, 1140, + 0, 0, 6664, 6665, 3, 590, 295, 0, 6665, 6666, 5, 1139, 0, 0, 6666, 613, + 1, 0, 0, 0, 6667, 6668, 5, 1138, 0, 0, 6668, 6671, 3, 590, 295, 0, 6669, + 6670, 5, 1140, 0, 0, 6670, 6672, 3, 590, 295, 0, 6671, 6669, 1, 0, 0, 0, + 6671, 6672, 1, 0, 0, 0, 6672, 6673, 1, 0, 0, 0, 6673, 6674, 5, 1139, 0, + 0, 6674, 615, 1, 0, 0, 0, 6675, 6680, 3, 584, 292, 0, 6676, 6677, 5, 1140, + 0, 0, 6677, 6679, 3, 584, 292, 0, 6678, 6676, 1, 0, 0, 0, 6679, 6682, 1, + 0, 0, 0, 6680, 6678, 1, 0, 0, 0, 6680, 6681, 1, 0, 0, 0, 6681, 617, 1, + 0, 0, 0, 6682, 6680, 1, 0, 0, 0, 6683, 6688, 3, 556, 278, 0, 6684, 6685, + 5, 1140, 0, 0, 6685, 6687, 3, 556, 278, 0, 6686, 6684, 1, 0, 0, 0, 6687, + 6690, 1, 0, 0, 0, 6688, 6686, 1, 0, 0, 0, 6688, 6689, 1, 0, 0, 0, 6689, + 619, 1, 0, 0, 0, 6690, 6688, 1, 0, 0, 0, 6691, 6696, 3, 552, 276, 0, 6692, + 6693, 5, 1140, 0, 0, 6693, 6695, 3, 552, 276, 0, 6694, 6692, 1, 0, 0, 0, + 6695, 6698, 1, 0, 0, 0, 6696, 6694, 1, 0, 0, 0, 6696, 6697, 1, 0, 0, 0, + 6697, 621, 1, 0, 0, 0, 6698, 6696, 1, 0, 0, 0, 6699, 6700, 5, 1138, 0, + 0, 6700, 6705, 3, 558, 279, 0, 6701, 6702, 5, 1140, 0, 0, 6702, 6704, 3, + 558, 279, 0, 6703, 6701, 1, 0, 0, 0, 6704, 6707, 1, 0, 0, 0, 6705, 6703, + 1, 0, 0, 0, 6705, 6706, 1, 0, 0, 0, 6706, 6708, 1, 0, 0, 0, 6707, 6705, + 1, 0, 0, 0, 6708, 6709, 5, 1139, 0, 0, 6709, 623, 1, 0, 0, 0, 6710, 6715, + 3, 688, 344, 0, 6711, 6712, 5, 1140, 0, 0, 6712, 6714, 3, 688, 344, 0, + 6713, 6711, 1, 0, 0, 0, 6714, 6717, 1, 0, 0, 0, 6715, 6713, 1, 0, 0, 0, + 6715, 6716, 1, 0, 0, 0, 6716, 625, 1, 0, 0, 0, 6717, 6715, 1, 0, 0, 0, + 6718, 6723, 3, 638, 319, 0, 6719, 6720, 5, 1140, 0, 0, 6720, 6722, 3, 638, + 319, 0, 6721, 6719, 1, 0, 0, 0, 6722, 6725, 1, 0, 0, 0, 6723, 6721, 1, + 0, 0, 0, 6723, 6724, 1, 0, 0, 0, 6724, 627, 1, 0, 0, 0, 6725, 6723, 1, + 0, 0, 0, 6726, 6731, 3, 602, 301, 0, 6727, 6728, 5, 1140, 0, 0, 6728, 6730, + 3, 602, 301, 0, 6729, 6727, 1, 0, 0, 0, 6730, 6733, 1, 0, 0, 0, 6731, 6729, + 1, 0, 0, 0, 6731, 6732, 1, 0, 0, 0, 6732, 629, 1, 0, 0, 0, 6733, 6731, + 1, 0, 0, 0, 6734, 6739, 5, 1153, 0, 0, 6735, 6736, 5, 1140, 0, 0, 6736, + 6738, 5, 1153, 0, 0, 6737, 6735, 1, 0, 0, 0, 6738, 6741, 1, 0, 0, 0, 6739, + 6737, 1, 0, 0, 0, 6739, 6740, 1, 0, 0, 0, 6740, 631, 1, 0, 0, 0, 6741, + 6739, 1, 0, 0, 0, 6742, 6747, 5, 1164, 0, 0, 6743, 6744, 5, 1140, 0, 0, + 6744, 6746, 5, 1164, 0, 0, 6745, 6743, 1, 0, 0, 0, 6746, 6749, 1, 0, 0, + 0, 6747, 6745, 1, 0, 0, 0, 6747, 6748, 1, 0, 0, 0, 6748, 633, 1, 0, 0, + 0, 6749, 6747, 1, 0, 0, 0, 6750, 6777, 5, 116, 0, 0, 6751, 6752, 5, 23, + 0, 0, 6752, 6753, 5, 1138, 0, 0, 6753, 6754, 3, 688, 344, 0, 6754, 6755, + 5, 12, 0, 0, 6755, 6756, 3, 608, 304, 0, 6756, 6757, 5, 1139, 0, 0, 6757, + 6777, 1, 0, 0, 0, 6758, 6760, 3, 694, 347, 0, 6759, 6758, 1, 0, 0, 0, 6759, + 6760, 1, 0, 0, 0, 6760, 6761, 1, 0, 0, 0, 6761, 6777, 3, 602, 301, 0, 6762, + 6766, 3, 636, 318, 0, 6763, 6764, 5, 118, 0, 0, 6764, 6765, 5, 184, 0, + 0, 6765, 6767, 3, 636, 318, 0, 6766, 6763, 1, 0, 0, 0, 6766, 6767, 1, 0, + 0, 0, 6767, 6777, 1, 0, 0, 0, 6768, 6769, 5, 1138, 0, 0, 6769, 6770, 3, + 688, 344, 0, 6770, 6771, 5, 1139, 0, 0, 6771, 6777, 1, 0, 0, 0, 6772, 6773, + 5, 1138, 0, 0, 6773, 6774, 3, 550, 275, 0, 6774, 6775, 5, 1139, 0, 0, 6775, + 6777, 1, 0, 0, 0, 6776, 6750, 1, 0, 0, 0, 6776, 6751, 1, 0, 0, 0, 6776, + 6759, 1, 0, 0, 0, 6776, 6762, 1, 0, 0, 0, 6776, 6768, 1, 0, 0, 0, 6776, + 6772, 1, 0, 0, 0, 6777, 635, 1, 0, 0, 0, 6778, 6784, 7, 115, 0, 0, 6779, + 6781, 5, 1138, 0, 0, 6780, 6782, 3, 590, 295, 0, 6781, 6780, 1, 0, 0, 0, + 6781, 6782, 1, 0, 0, 0, 6782, 6783, 1, 0, 0, 0, 6783, 6785, 5, 1139, 0, + 0, 6784, 6779, 1, 0, 0, 0, 6784, 6785, 1, 0, 0, 0, 6785, 6793, 1, 0, 0, + 0, 6786, 6787, 5, 324, 0, 0, 6787, 6789, 5, 1138, 0, 0, 6788, 6790, 3, + 590, 295, 0, 6789, 6788, 1, 0, 0, 0, 6789, 6790, 1, 0, 0, 0, 6790, 6791, + 1, 0, 0, 0, 6791, 6793, 5, 1139, 0, 0, 6792, 6778, 1, 0, 0, 0, 6792, 6786, + 1, 0, 0, 0, 6793, 637, 1, 0, 0, 0, 6794, 6797, 3, 688, 344, 0, 6795, 6797, + 5, 42, 0, 0, 6796, 6794, 1, 0, 0, 0, 6796, 6795, 1, 0, 0, 0, 6797, 639, + 1, 0, 0, 0, 6798, 6799, 5, 77, 0, 0, 6799, 6800, 5, 60, 0, 0, 6800, 641, + 1, 0, 0, 0, 6801, 6802, 5, 77, 0, 0, 6802, 6803, 5, 114, 0, 0, 6803, 6804, + 5, 60, 0, 0, 6804, 643, 1, 0, 0, 0, 6805, 6806, 5, 123, 0, 0, 6806, 6807, + 5, 141, 0, 0, 6807, 645, 1, 0, 0, 0, 6808, 6809, 5, 675, 0, 0, 6809, 6812, + 3, 590, 295, 0, 6810, 6812, 5, 528, 0, 0, 6811, 6808, 1, 0, 0, 0, 6811, + 6810, 1, 0, 0, 0, 6812, 647, 1, 0, 0, 0, 6813, 6832, 3, 650, 325, 0, 6814, + 6832, 3, 658, 329, 0, 6815, 6832, 3, 660, 330, 0, 6816, 6817, 3, 680, 340, + 0, 6817, 6819, 5, 1138, 0, 0, 6818, 6820, 3, 684, 342, 0, 6819, 6818, 1, + 0, 0, 0, 6819, 6820, 1, 0, 0, 0, 6820, 6821, 1, 0, 0, 0, 6821, 6822, 5, + 1139, 0, 0, 6822, 6832, 1, 0, 0, 0, 6823, 6824, 3, 550, 275, 0, 6824, 6826, + 5, 1138, 0, 0, 6825, 6827, 3, 684, 342, 0, 6826, 6825, 1, 0, 0, 0, 6826, + 6827, 1, 0, 0, 0, 6827, 6828, 1, 0, 0, 0, 6828, 6829, 5, 1139, 0, 0, 6829, + 6832, 1, 0, 0, 0, 6830, 6832, 3, 682, 341, 0, 6831, 6813, 1, 0, 0, 0, 6831, + 6814, 1, 0, 0, 0, 6831, 6815, 1, 0, 0, 0, 6831, 6816, 1, 0, 0, 0, 6831, + 6823, 1, 0, 0, 0, 6831, 6830, 1, 0, 0, 0, 6832, 649, 1, 0, 0, 0, 6833, + 6836, 7, 116, 0, 0, 6834, 6835, 5, 1138, 0, 0, 6835, 6837, 5, 1139, 0, + 0, 6836, 6834, 1, 0, 0, 0, 6836, 6837, 1, 0, 0, 0, 6837, 7013, 1, 0, 0, + 0, 6838, 7013, 3, 62, 31, 0, 6839, 6840, 5, 32, 0, 0, 6840, 6841, 5, 1138, + 0, 0, 6841, 6842, 3, 688, 344, 0, 6842, 6843, 5, 1140, 0, 0, 6843, 6844, + 3, 608, 304, 0, 6844, 6845, 5, 1139, 0, 0, 6845, 7013, 1, 0, 0, 0, 6846, + 6847, 5, 32, 0, 0, 6847, 6848, 5, 1138, 0, 0, 6848, 6849, 3, 688, 344, + 0, 6849, 6850, 5, 187, 0, 0, 6850, 6851, 3, 568, 284, 0, 6851, 6852, 5, + 1139, 0, 0, 6852, 7013, 1, 0, 0, 0, 6853, 6854, 5, 23, 0, 0, 6854, 6855, + 5, 1138, 0, 0, 6855, 6856, 3, 688, 344, 0, 6856, 6857, 5, 12, 0, 0, 6857, + 6858, 3, 608, 304, 0, 6858, 6859, 5, 1139, 0, 0, 6859, 7013, 1, 0, 0, 0, + 6860, 6861, 5, 188, 0, 0, 6861, 6862, 5, 1138, 0, 0, 6862, 6863, 3, 556, + 278, 0, 6863, 6864, 5, 1139, 0, 0, 6864, 7013, 1, 0, 0, 0, 6865, 6866, + 5, 22, 0, 0, 6866, 6868, 3, 688, 344, 0, 6867, 6869, 3, 652, 326, 0, 6868, + 6867, 1, 0, 0, 0, 6869, 6870, 1, 0, 0, 0, 6870, 6868, 1, 0, 0, 0, 6870, + 6871, 1, 0, 0, 0, 6871, 6874, 1, 0, 0, 0, 6872, 6873, 5, 53, 0, 0, 6873, + 6875, 3, 686, 343, 0, 6874, 6872, 1, 0, 0, 0, 6874, 6875, 1, 0, 0, 0, 6875, + 6876, 1, 0, 0, 0, 6876, 6877, 5, 408, 0, 0, 6877, 7013, 1, 0, 0, 0, 6878, + 6880, 5, 22, 0, 0, 6879, 6881, 3, 652, 326, 0, 6880, 6879, 1, 0, 0, 0, + 6881, 6882, 1, 0, 0, 0, 6882, 6880, 1, 0, 0, 0, 6882, 6883, 1, 0, 0, 0, + 6883, 6886, 1, 0, 0, 0, 6884, 6885, 5, 53, 0, 0, 6885, 6887, 3, 686, 343, + 0, 6886, 6884, 1, 0, 0, 0, 6886, 6887, 1, 0, 0, 0, 6887, 6888, 1, 0, 0, + 0, 6888, 6889, 5, 408, 0, 0, 6889, 7013, 1, 0, 0, 0, 6890, 6891, 5, 222, + 0, 0, 6891, 6892, 5, 1138, 0, 0, 6892, 6895, 3, 684, 342, 0, 6893, 6894, + 5, 187, 0, 0, 6894, 6896, 3, 568, 284, 0, 6895, 6893, 1, 0, 0, 0, 6895, + 6896, 1, 0, 0, 0, 6896, 6897, 1, 0, 0, 0, 6897, 6898, 5, 1139, 0, 0, 6898, + 7013, 1, 0, 0, 0, 6899, 6900, 5, 325, 0, 0, 6900, 6903, 5, 1138, 0, 0, + 6901, 6904, 3, 594, 297, 0, 6902, 6904, 3, 688, 344, 0, 6903, 6901, 1, + 0, 0, 0, 6903, 6902, 1, 0, 0, 0, 6904, 6905, 1, 0, 0, 0, 6905, 6908, 5, + 80, 0, 0, 6906, 6909, 3, 594, 297, 0, 6907, 6909, 3, 688, 344, 0, 6908, + 6906, 1, 0, 0, 0, 6908, 6907, 1, 0, 0, 0, 6909, 6910, 1, 0, 0, 0, 6910, + 6911, 5, 1139, 0, 0, 6911, 7013, 1, 0, 0, 0, 6912, 6913, 7, 117, 0, 0, + 6913, 6916, 5, 1138, 0, 0, 6914, 6917, 3, 594, 297, 0, 6915, 6917, 3, 688, + 344, 0, 6916, 6914, 1, 0, 0, 0, 6916, 6915, 1, 0, 0, 0, 6917, 6918, 1, + 0, 0, 0, 6918, 6921, 5, 68, 0, 0, 6919, 6922, 3, 590, 295, 0, 6920, 6922, + 3, 688, 344, 0, 6921, 6919, 1, 0, 0, 0, 6921, 6920, 1, 0, 0, 0, 6922, 6928, + 1, 0, 0, 0, 6923, 6926, 5, 65, 0, 0, 6924, 6927, 3, 590, 295, 0, 6925, + 6927, 3, 688, 344, 0, 6926, 6924, 1, 0, 0, 0, 6926, 6925, 1, 0, 0, 0, 6927, + 6929, 1, 0, 0, 0, 6928, 6923, 1, 0, 0, 0, 6928, 6929, 1, 0, 0, 0, 6929, + 6930, 1, 0, 0, 0, 6930, 6931, 5, 1139, 0, 0, 6931, 7013, 1, 0, 0, 0, 6932, + 6933, 5, 329, 0, 0, 6933, 6934, 5, 1138, 0, 0, 6934, 6937, 7, 118, 0, 0, + 6935, 6938, 3, 594, 297, 0, 6936, 6938, 3, 688, 344, 0, 6937, 6935, 1, + 0, 0, 0, 6937, 6936, 1, 0, 0, 0, 6937, 6938, 1, 0, 0, 0, 6938, 6939, 1, + 0, 0, 0, 6939, 6942, 5, 68, 0, 0, 6940, 6943, 3, 594, 297, 0, 6941, 6943, + 3, 688, 344, 0, 6942, 6940, 1, 0, 0, 0, 6942, 6941, 1, 0, 0, 0, 6943, 6944, + 1, 0, 0, 0, 6944, 6945, 5, 1139, 0, 0, 6945, 7013, 1, 0, 0, 0, 6946, 6947, + 5, 329, 0, 0, 6947, 6950, 5, 1138, 0, 0, 6948, 6951, 3, 594, 297, 0, 6949, + 6951, 3, 688, 344, 0, 6950, 6948, 1, 0, 0, 0, 6950, 6949, 1, 0, 0, 0, 6951, + 6952, 1, 0, 0, 0, 6952, 6955, 5, 68, 0, 0, 6953, 6956, 3, 594, 297, 0, + 6954, 6956, 3, 688, 344, 0, 6955, 6953, 1, 0, 0, 0, 6955, 6954, 1, 0, 0, + 0, 6956, 6957, 1, 0, 0, 0, 6957, 6958, 5, 1139, 0, 0, 6958, 7013, 1, 0, + 0, 0, 6959, 6960, 5, 1108, 0, 0, 6960, 6963, 5, 1138, 0, 0, 6961, 6964, + 3, 594, 297, 0, 6962, 6964, 3, 688, 344, 0, 6963, 6961, 1, 0, 0, 0, 6963, + 6962, 1, 0, 0, 0, 6964, 6971, 1, 0, 0, 0, 6965, 6966, 5, 12, 0, 0, 6966, + 6967, 7, 119, 0, 0, 6967, 6968, 5, 1138, 0, 0, 6968, 6969, 3, 590, 295, + 0, 6969, 6970, 5, 1139, 0, 0, 6970, 6972, 1, 0, 0, 0, 6971, 6965, 1, 0, + 0, 0, 6971, 6972, 1, 0, 0, 0, 6972, 6974, 1, 0, 0, 0, 6973, 6975, 3, 654, + 327, 0, 6974, 6973, 1, 0, 0, 0, 6974, 6975, 1, 0, 0, 0, 6975, 6976, 1, + 0, 0, 0, 6976, 6977, 5, 1139, 0, 0, 6977, 7013, 1, 0, 0, 0, 6978, 6979, + 5, 322, 0, 0, 6979, 6980, 5, 1138, 0, 0, 6980, 6981, 3, 72, 36, 0, 6981, + 6984, 5, 68, 0, 0, 6982, 6985, 3, 594, 297, 0, 6983, 6985, 3, 688, 344, + 0, 6984, 6982, 1, 0, 0, 0, 6984, 6983, 1, 0, 0, 0, 6985, 6986, 1, 0, 0, + 0, 6986, 6987, 5, 1139, 0, 0, 6987, 7013, 1, 0, 0, 0, 6988, 6989, 5, 902, + 0, 0, 6989, 6990, 5, 1138, 0, 0, 6990, 6991, 7, 120, 0, 0, 6991, 6992, + 5, 1140, 0, 0, 6992, 6993, 3, 594, 297, 0, 6993, 6994, 5, 1139, 0, 0, 6994, + 7013, 1, 0, 0, 0, 6995, 6996, 5, 283, 0, 0, 6996, 6997, 5, 1138, 0, 0, + 6997, 6998, 3, 688, 344, 0, 6998, 6999, 5, 1140, 0, 0, 6999, 7002, 3, 688, + 344, 0, 7000, 7001, 5, 594, 0, 0, 7001, 7003, 3, 608, 304, 0, 7002, 7000, + 1, 0, 0, 0, 7002, 7003, 1, 0, 0, 0, 7003, 7005, 1, 0, 0, 0, 7004, 7006, + 3, 268, 134, 0, 7005, 7004, 1, 0, 0, 0, 7005, 7006, 1, 0, 0, 0, 7006, 7008, + 1, 0, 0, 0, 7007, 7009, 3, 270, 135, 0, 7008, 7007, 1, 0, 0, 0, 7008, 7009, + 1, 0, 0, 0, 7009, 7010, 1, 0, 0, 0, 7010, 7011, 5, 1139, 0, 0, 7011, 7013, + 1, 0, 0, 0, 7012, 6833, 1, 0, 0, 0, 7012, 6838, 1, 0, 0, 0, 7012, 6839, + 1, 0, 0, 0, 7012, 6846, 1, 0, 0, 0, 7012, 6853, 1, 0, 0, 0, 7012, 6860, + 1, 0, 0, 0, 7012, 6865, 1, 0, 0, 0, 7012, 6878, 1, 0, 0, 0, 7012, 6890, + 1, 0, 0, 0, 7012, 6899, 1, 0, 0, 0, 7012, 6912, 1, 0, 0, 0, 7012, 6932, + 1, 0, 0, 0, 7012, 6946, 1, 0, 0, 0, 7012, 6959, 1, 0, 0, 0, 7012, 6978, + 1, 0, 0, 0, 7012, 6988, 1, 0, 0, 0, 7012, 6995, 1, 0, 0, 0, 7013, 651, + 1, 0, 0, 0, 7014, 7015, 5, 189, 0, 0, 7015, 7016, 3, 686, 343, 0, 7016, + 7017, 5, 174, 0, 0, 7017, 7018, 3, 686, 343, 0, 7018, 653, 1, 0, 0, 0, + 7019, 7020, 5, 473, 0, 0, 7020, 7025, 3, 656, 328, 0, 7021, 7022, 5, 1140, + 0, 0, 7022, 7024, 3, 656, 328, 0, 7023, 7021, 1, 0, 0, 0, 7024, 7027, 1, + 0, 0, 0, 7025, 7023, 1, 0, 0, 0, 7025, 7026, 1, 0, 0, 0, 7026, 7034, 1, + 0, 0, 0, 7027, 7025, 1, 0, 0, 0, 7028, 7029, 5, 473, 0, 0, 7029, 7030, + 3, 590, 295, 0, 7030, 7031, 5, 1126, 0, 0, 7031, 7032, 3, 590, 295, 0, + 7032, 7034, 1, 0, 0, 0, 7033, 7019, 1, 0, 0, 0, 7033, 7028, 1, 0, 0, 0, + 7034, 655, 1, 0, 0, 0, 7035, 7037, 3, 590, 295, 0, 7036, 7038, 7, 121, + 0, 0, 7037, 7036, 1, 0, 0, 0, 7037, 7038, 1, 0, 0, 0, 7038, 657, 1, 0, + 0, 0, 7039, 7040, 7, 122, 0, 0, 7040, 7042, 5, 1138, 0, 0, 7041, 7043, + 7, 44, 0, 0, 7042, 7041, 1, 0, 0, 0, 7042, 7043, 1, 0, 0, 0, 7043, 7044, + 1, 0, 0, 0, 7044, 7045, 3, 686, 343, 0, 7045, 7047, 5, 1139, 0, 0, 7046, + 7048, 3, 662, 331, 0, 7047, 7046, 1, 0, 0, 0, 7047, 7048, 1, 0, 0, 0, 7048, + 7099, 1, 0, 0, 0, 7049, 7050, 5, 291, 0, 0, 7050, 7058, 5, 1138, 0, 0, + 7051, 7059, 5, 1122, 0, 0, 7052, 7054, 5, 6, 0, 0, 7053, 7052, 1, 0, 0, + 0, 7053, 7054, 1, 0, 0, 0, 7054, 7055, 1, 0, 0, 0, 7055, 7059, 3, 686, + 343, 0, 7056, 7057, 5, 49, 0, 0, 7057, 7059, 3, 684, 342, 0, 7058, 7051, + 1, 0, 0, 0, 7058, 7053, 1, 0, 0, 0, 7058, 7056, 1, 0, 0, 0, 7059, 7060, + 1, 0, 0, 0, 7060, 7062, 5, 1139, 0, 0, 7061, 7063, 3, 662, 331, 0, 7062, + 7061, 1, 0, 0, 0, 7062, 7063, 1, 0, 0, 0, 7063, 7099, 1, 0, 0, 0, 7064, + 7065, 7, 123, 0, 0, 7065, 7067, 5, 1138, 0, 0, 7066, 7068, 5, 6, 0, 0, + 7067, 7066, 1, 0, 0, 0, 7067, 7068, 1, 0, 0, 0, 7068, 7069, 1, 0, 0, 0, + 7069, 7070, 3, 686, 343, 0, 7070, 7072, 5, 1139, 0, 0, 7071, 7073, 3, 662, + 331, 0, 7072, 7071, 1, 0, 0, 0, 7072, 7073, 1, 0, 0, 0, 7073, 7099, 1, + 0, 0, 0, 7074, 7075, 5, 295, 0, 0, 7075, 7077, 5, 1138, 0, 0, 7076, 7078, + 5, 49, 0, 0, 7077, 7076, 1, 0, 0, 0, 7077, 7078, 1, 0, 0, 0, 7078, 7079, + 1, 0, 0, 0, 7079, 7090, 3, 684, 342, 0, 7080, 7081, 5, 124, 0, 0, 7081, + 7082, 5, 19, 0, 0, 7082, 7087, 3, 232, 116, 0, 7083, 7084, 5, 1140, 0, + 0, 7084, 7086, 3, 232, 116, 0, 7085, 7083, 1, 0, 0, 0, 7086, 7089, 1, 0, + 0, 0, 7087, 7085, 1, 0, 0, 0, 7087, 7088, 1, 0, 0, 0, 7088, 7091, 1, 0, + 0, 0, 7089, 7087, 1, 0, 0, 0, 7090, 7080, 1, 0, 0, 0, 7090, 7091, 1, 0, + 0, 0, 7091, 7094, 1, 0, 0, 0, 7092, 7093, 5, 154, 0, 0, 7093, 7095, 5, + 1153, 0, 0, 7094, 7092, 1, 0, 0, 0, 7094, 7095, 1, 0, 0, 0, 7095, 7096, + 1, 0, 0, 0, 7096, 7097, 5, 1139, 0, 0, 7097, 7099, 1, 0, 0, 0, 7098, 7039, + 1, 0, 0, 0, 7098, 7049, 1, 0, 0, 0, 7098, 7064, 1, 0, 0, 0, 7098, 7074, + 1, 0, 0, 0, 7099, 659, 1, 0, 0, 0, 7100, 7101, 7, 124, 0, 0, 7101, 7102, + 5, 1138, 0, 0, 7102, 7105, 3, 688, 344, 0, 7103, 7104, 5, 1140, 0, 0, 7104, + 7106, 3, 590, 295, 0, 7105, 7103, 1, 0, 0, 0, 7105, 7106, 1, 0, 0, 0, 7106, + 7109, 1, 0, 0, 0, 7107, 7108, 5, 1140, 0, 0, 7108, 7110, 3, 590, 295, 0, + 7109, 7107, 1, 0, 0, 0, 7109, 7110, 1, 0, 0, 0, 7110, 7111, 1, 0, 0, 0, + 7111, 7112, 5, 1139, 0, 0, 7112, 7113, 3, 662, 331, 0, 7113, 7139, 1, 0, + 0, 0, 7114, 7115, 7, 125, 0, 0, 7115, 7116, 5, 1138, 0, 0, 7116, 7117, + 3, 688, 344, 0, 7117, 7118, 5, 1139, 0, 0, 7118, 7119, 3, 662, 331, 0, + 7119, 7139, 1, 0, 0, 0, 7120, 7121, 7, 126, 0, 0, 7121, 7122, 5, 1138, + 0, 0, 7122, 7123, 5, 1139, 0, 0, 7123, 7139, 3, 662, 331, 0, 7124, 7125, + 5, 302, 0, 0, 7125, 7126, 5, 1138, 0, 0, 7126, 7127, 3, 688, 344, 0, 7127, + 7128, 5, 1140, 0, 0, 7128, 7129, 3, 590, 295, 0, 7129, 7130, 5, 1139, 0, + 0, 7130, 7131, 3, 662, 331, 0, 7131, 7139, 1, 0, 0, 0, 7132, 7133, 5, 301, + 0, 0, 7133, 7134, 5, 1138, 0, 0, 7134, 7135, 3, 590, 295, 0, 7135, 7136, + 5, 1139, 0, 0, 7136, 7137, 3, 662, 331, 0, 7137, 7139, 1, 0, 0, 0, 7138, + 7100, 1, 0, 0, 0, 7138, 7114, 1, 0, 0, 0, 7138, 7120, 1, 0, 0, 0, 7138, + 7124, 1, 0, 0, 0, 7138, 7132, 1, 0, 0, 0, 7139, 661, 1, 0, 0, 0, 7140, + 7146, 5, 128, 0, 0, 7141, 7142, 5, 1138, 0, 0, 7142, 7143, 3, 664, 332, + 0, 7143, 7144, 5, 1139, 0, 0, 7144, 7147, 1, 0, 0, 0, 7145, 7147, 3, 666, + 333, 0, 7146, 7141, 1, 0, 0, 0, 7146, 7145, 1, 0, 0, 0, 7147, 663, 1, 0, + 0, 0, 7148, 7150, 3, 666, 333, 0, 7149, 7148, 1, 0, 0, 0, 7149, 7150, 1, + 0, 0, 0, 7150, 7152, 1, 0, 0, 0, 7151, 7153, 3, 678, 339, 0, 7152, 7151, + 1, 0, 0, 0, 7152, 7153, 1, 0, 0, 0, 7153, 7155, 1, 0, 0, 0, 7154, 7156, + 3, 230, 115, 0, 7155, 7154, 1, 0, 0, 0, 7155, 7156, 1, 0, 0, 0, 7156, 7158, + 1, 0, 0, 0, 7157, 7159, 3, 668, 334, 0, 7158, 7157, 1, 0, 0, 0, 7158, 7159, + 1, 0, 0, 0, 7159, 665, 1, 0, 0, 0, 7160, 7161, 3, 584, 292, 0, 7161, 667, + 1, 0, 0, 0, 7162, 7163, 3, 670, 335, 0, 7163, 7164, 3, 672, 336, 0, 7164, + 669, 1, 0, 0, 0, 7165, 7166, 7, 127, 0, 0, 7166, 671, 1, 0, 0, 0, 7167, + 7170, 3, 676, 338, 0, 7168, 7170, 3, 674, 337, 0, 7169, 7167, 1, 0, 0, + 0, 7169, 7168, 1, 0, 0, 0, 7170, 673, 1, 0, 0, 0, 7171, 7172, 5, 16, 0, + 0, 7172, 7173, 3, 676, 338, 0, 7173, 7174, 5, 10, 0, 0, 7174, 7175, 3, + 676, 338, 0, 7175, 675, 1, 0, 0, 0, 7176, 7177, 5, 35, 0, 0, 7177, 7184, + 5, 601, 0, 0, 7178, 7179, 5, 658, 0, 0, 7179, 7184, 7, 128, 0, 0, 7180, + 7181, 3, 688, 344, 0, 7181, 7182, 7, 128, 0, 0, 7182, 7184, 1, 0, 0, 0, + 7183, 7176, 1, 0, 0, 0, 7183, 7178, 1, 0, 0, 0, 7183, 7180, 1, 0, 0, 0, + 7184, 677, 1, 0, 0, 0, 7185, 7186, 5, 129, 0, 0, 7186, 7187, 5, 19, 0, + 0, 7187, 7192, 3, 688, 344, 0, 7188, 7189, 5, 1140, 0, 0, 7189, 7191, 3, + 688, 344, 0, 7190, 7188, 1, 0, 0, 0, 7191, 7194, 1, 0, 0, 0, 7192, 7190, + 1, 0, 0, 0, 7192, 7193, 1, 0, 0, 0, 7193, 679, 1, 0, 0, 0, 7194, 7192, + 1, 0, 0, 0, 7195, 7220, 3, 720, 360, 0, 7196, 7220, 5, 748, 0, 0, 7197, + 7220, 5, 318, 0, 0, 7198, 7220, 5, 314, 0, 0, 7199, 7220, 5, 315, 0, 0, + 7200, 7220, 5, 316, 0, 0, 7201, 7220, 5, 319, 0, 0, 7202, 7220, 5, 320, + 0, 0, 7203, 7220, 5, 321, 0, 0, 7204, 7220, 5, 77, 0, 0, 7205, 7220, 5, + 85, 0, 0, 7206, 7220, 5, 317, 0, 0, 7207, 7220, 5, 323, 0, 0, 7208, 7220, + 5, 509, 0, 0, 7209, 7220, 5, 324, 0, 0, 7210, 7220, 5, 140, 0, 0, 7211, + 7220, 5, 141, 0, 0, 7212, 7220, 5, 326, 0, 0, 7213, 7220, 5, 327, 0, 0, + 7214, 7220, 5, 328, 0, 0, 7215, 7220, 5, 329, 0, 0, 7216, 7220, 5, 330, + 0, 0, 7217, 7220, 5, 331, 0, 0, 7218, 7220, 5, 332, 0, 0, 7219, 7195, 1, + 0, 0, 0, 7219, 7196, 1, 0, 0, 0, 7219, 7197, 1, 0, 0, 0, 7219, 7198, 1, + 0, 0, 0, 7219, 7199, 1, 0, 0, 0, 7219, 7200, 1, 0, 0, 0, 7219, 7201, 1, + 0, 0, 0, 7219, 7202, 1, 0, 0, 0, 7219, 7203, 1, 0, 0, 0, 7219, 7204, 1, + 0, 0, 0, 7219, 7205, 1, 0, 0, 0, 7219, 7206, 1, 0, 0, 0, 7219, 7207, 1, + 0, 0, 0, 7219, 7208, 1, 0, 0, 0, 7219, 7209, 1, 0, 0, 0, 7219, 7210, 1, + 0, 0, 0, 7219, 7211, 1, 0, 0, 0, 7219, 7212, 1, 0, 0, 0, 7219, 7213, 1, + 0, 0, 0, 7219, 7214, 1, 0, 0, 0, 7219, 7215, 1, 0, 0, 0, 7219, 7216, 1, + 0, 0, 0, 7219, 7217, 1, 0, 0, 0, 7219, 7218, 1, 0, 0, 0, 7220, 681, 1, + 0, 0, 0, 7221, 7222, 7, 129, 0, 0, 7222, 7223, 5, 1138, 0, 0, 7223, 7224, + 3, 686, 343, 0, 7224, 7225, 5, 1139, 0, 0, 7225, 683, 1, 0, 0, 0, 7226, + 7231, 3, 602, 301, 0, 7227, 7231, 3, 556, 278, 0, 7228, 7231, 3, 648, 324, + 0, 7229, 7231, 3, 688, 344, 0, 7230, 7226, 1, 0, 0, 0, 7230, 7227, 1, 0, + 0, 0, 7230, 7228, 1, 0, 0, 0, 7230, 7229, 1, 0, 0, 0, 7231, 7241, 1, 0, + 0, 0, 7232, 7237, 5, 1140, 0, 0, 7233, 7238, 3, 602, 301, 0, 7234, 7238, + 3, 556, 278, 0, 7235, 7238, 3, 648, 324, 0, 7236, 7238, 3, 688, 344, 0, + 7237, 7233, 1, 0, 0, 0, 7237, 7234, 1, 0, 0, 0, 7237, 7235, 1, 0, 0, 0, + 7237, 7236, 1, 0, 0, 0, 7238, 7240, 1, 0, 0, 0, 7239, 7232, 1, 0, 0, 0, + 7240, 7243, 1, 0, 0, 0, 7241, 7239, 1, 0, 0, 0, 7241, 7242, 1, 0, 0, 0, + 7242, 685, 1, 0, 0, 0, 7243, 7241, 1, 0, 0, 0, 7244, 7249, 3, 602, 301, + 0, 7245, 7249, 3, 556, 278, 0, 7246, 7249, 3, 648, 324, 0, 7247, 7249, + 3, 688, 344, 0, 7248, 7244, 1, 0, 0, 0, 7248, 7245, 1, 0, 0, 0, 7248, 7246, + 1, 0, 0, 0, 7248, 7247, 1, 0, 0, 0, 7249, 687, 1, 0, 0, 0, 7250, 7251, + 6, 344, -1, 0, 7251, 7252, 7, 130, 0, 0, 7252, 7262, 3, 688, 344, 4, 7253, + 7254, 3, 690, 345, 0, 7254, 7256, 5, 88, 0, 0, 7255, 7257, 5, 114, 0, 0, + 7256, 7255, 1, 0, 0, 0, 7256, 7257, 1, 0, 0, 0, 7257, 7258, 1, 0, 0, 0, + 7258, 7259, 7, 131, 0, 0, 7259, 7262, 1, 0, 0, 0, 7260, 7262, 3, 690, 345, + 0, 7261, 7250, 1, 0, 0, 0, 7261, 7253, 1, 0, 0, 0, 7261, 7260, 1, 0, 0, + 0, 7262, 7269, 1, 0, 0, 0, 7263, 7264, 10, 3, 0, 0, 7264, 7265, 3, 698, + 349, 0, 7265, 7266, 3, 688, 344, 4, 7266, 7268, 1, 0, 0, 0, 7267, 7263, + 1, 0, 0, 0, 7268, 7271, 1, 0, 0, 0, 7269, 7267, 1, 0, 0, 0, 7269, 7270, + 1, 0, 0, 0, 7270, 689, 1, 0, 0, 0, 7271, 7269, 1, 0, 0, 0, 7272, 7273, + 6, 345, -1, 0, 7273, 7274, 3, 692, 346, 0, 7274, 7339, 1, 0, 0, 0, 7275, + 7276, 10, 8, 0, 0, 7276, 7277, 3, 696, 348, 0, 7277, 7278, 3, 690, 345, + 9, 7278, 7338, 1, 0, 0, 0, 7279, 7281, 10, 6, 0, 0, 7280, 7282, 5, 114, + 0, 0, 7281, 7280, 1, 0, 0, 0, 7281, 7282, 1, 0, 0, 0, 7282, 7283, 1, 0, + 0, 0, 7283, 7284, 5, 16, 0, 0, 7284, 7285, 3, 690, 345, 0, 7285, 7286, + 5, 10, 0, 0, 7286, 7287, 3, 690, 345, 7, 7287, 7338, 1, 0, 0, 0, 7288, + 7289, 10, 5, 0, 0, 7289, 7290, 5, 621, 0, 0, 7290, 7291, 5, 98, 0, 0, 7291, + 7338, 3, 690, 345, 6, 7292, 7294, 10, 3, 0, 0, 7293, 7295, 5, 114, 0, 0, + 7294, 7293, 1, 0, 0, 0, 7294, 7295, 1, 0, 0, 0, 7295, 7296, 1, 0, 0, 0, + 7296, 7297, 7, 132, 0, 0, 7297, 7338, 3, 690, 345, 4, 7298, 7300, 10, 10, + 0, 0, 7299, 7301, 5, 114, 0, 0, 7300, 7299, 1, 0, 0, 0, 7300, 7301, 1, + 0, 0, 0, 7301, 7302, 1, 0, 0, 0, 7302, 7303, 5, 80, 0, 0, 7303, 7306, 5, + 1138, 0, 0, 7304, 7307, 3, 200, 100, 0, 7305, 7307, 3, 624, 312, 0, 7306, + 7304, 1, 0, 0, 0, 7306, 7305, 1, 0, 0, 0, 7307, 7308, 1, 0, 0, 0, 7308, + 7309, 5, 1139, 0, 0, 7309, 7338, 1, 0, 0, 0, 7310, 7311, 10, 9, 0, 0, 7311, + 7312, 5, 88, 0, 0, 7312, 7338, 3, 600, 300, 0, 7313, 7314, 10, 7, 0, 0, + 7314, 7315, 3, 696, 348, 0, 7315, 7316, 7, 133, 0, 0, 7316, 7317, 5, 1138, + 0, 0, 7317, 7318, 3, 200, 100, 0, 7318, 7319, 5, 1139, 0, 0, 7319, 7338, + 1, 0, 0, 0, 7320, 7322, 10, 4, 0, 0, 7321, 7323, 5, 114, 0, 0, 7322, 7321, + 1, 0, 0, 0, 7322, 7323, 1, 0, 0, 0, 7323, 7324, 1, 0, 0, 0, 7324, 7325, + 5, 98, 0, 0, 7325, 7328, 3, 690, 345, 0, 7326, 7327, 5, 414, 0, 0, 7327, + 7329, 5, 1153, 0, 0, 7328, 7326, 1, 0, 0, 0, 7328, 7329, 1, 0, 0, 0, 7329, + 7338, 1, 0, 0, 0, 7330, 7331, 10, 2, 0, 0, 7331, 7332, 5, 506, 0, 0, 7332, + 7333, 5, 534, 0, 0, 7333, 7334, 5, 1138, 0, 0, 7334, 7335, 3, 690, 345, + 0, 7335, 7336, 5, 1139, 0, 0, 7336, 7338, 1, 0, 0, 0, 7337, 7275, 1, 0, + 0, 0, 7337, 7279, 1, 0, 0, 0, 7337, 7288, 1, 0, 0, 0, 7337, 7292, 1, 0, + 0, 0, 7337, 7298, 1, 0, 0, 0, 7337, 7310, 1, 0, 0, 0, 7337, 7313, 1, 0, + 0, 0, 7337, 7320, 1, 0, 0, 0, 7337, 7330, 1, 0, 0, 0, 7338, 7341, 1, 0, + 0, 0, 7339, 7337, 1, 0, 0, 0, 7339, 7340, 1, 0, 0, 0, 7340, 691, 1, 0, + 0, 0, 7341, 7339, 1, 0, 0, 0, 7342, 7343, 6, 346, -1, 0, 7343, 7391, 3, + 602, 301, 0, 7344, 7391, 3, 556, 278, 0, 7345, 7391, 3, 648, 324, 0, 7346, + 7391, 3, 566, 283, 0, 7347, 7348, 3, 694, 347, 0, 7348, 7349, 3, 692, 346, + 12, 7349, 7391, 1, 0, 0, 0, 7350, 7351, 5, 226, 0, 0, 7351, 7391, 3, 692, + 346, 11, 7352, 7353, 5, 1164, 0, 0, 7353, 7354, 5, 1113, 0, 0, 7354, 7391, + 3, 692, 346, 10, 7355, 7356, 5, 1138, 0, 0, 7356, 7361, 3, 688, 344, 0, + 7357, 7358, 5, 1140, 0, 0, 7358, 7360, 3, 688, 344, 0, 7359, 7357, 1, 0, + 0, 0, 7360, 7363, 1, 0, 0, 0, 7361, 7359, 1, 0, 0, 0, 7361, 7362, 1, 0, + 0, 0, 7362, 7364, 1, 0, 0, 0, 7363, 7361, 1, 0, 0, 0, 7364, 7365, 5, 1139, + 0, 0, 7365, 7391, 1, 0, 0, 0, 7366, 7367, 5, 601, 0, 0, 7367, 7368, 5, + 1138, 0, 0, 7368, 7371, 3, 688, 344, 0, 7369, 7370, 5, 1140, 0, 0, 7370, + 7372, 3, 688, 344, 0, 7371, 7369, 1, 0, 0, 0, 7372, 7373, 1, 0, 0, 0, 7373, + 7371, 1, 0, 0, 0, 7373, 7374, 1, 0, 0, 0, 7374, 7375, 1, 0, 0, 0, 7375, + 7376, 5, 1139, 0, 0, 7376, 7391, 1, 0, 0, 0, 7377, 7378, 5, 60, 0, 0, 7378, + 7379, 5, 1138, 0, 0, 7379, 7380, 3, 200, 100, 0, 7380, 7381, 5, 1139, 0, + 0, 7381, 7391, 1, 0, 0, 0, 7382, 7383, 5, 1138, 0, 0, 7383, 7384, 3, 200, + 100, 0, 7384, 7385, 5, 1139, 0, 0, 7385, 7391, 1, 0, 0, 0, 7386, 7387, + 5, 86, 0, 0, 7387, 7388, 3, 688, 344, 0, 7388, 7389, 3, 72, 36, 0, 7389, + 7391, 1, 0, 0, 0, 7390, 7342, 1, 0, 0, 0, 7390, 7344, 1, 0, 0, 0, 7390, + 7345, 1, 0, 0, 0, 7390, 7346, 1, 0, 0, 0, 7390, 7347, 1, 0, 0, 0, 7390, + 7350, 1, 0, 0, 0, 7390, 7352, 1, 0, 0, 0, 7390, 7355, 1, 0, 0, 0, 7390, + 7366, 1, 0, 0, 0, 7390, 7377, 1, 0, 0, 0, 7390, 7382, 1, 0, 0, 0, 7390, + 7386, 1, 0, 0, 0, 7391, 7413, 1, 0, 0, 0, 7392, 7393, 10, 4, 0, 0, 7393, + 7394, 3, 700, 350, 0, 7394, 7395, 3, 692, 346, 5, 7395, 7412, 1, 0, 0, + 0, 7396, 7397, 10, 3, 0, 0, 7397, 7398, 3, 702, 351, 0, 7398, 7399, 3, + 692, 346, 4, 7399, 7412, 1, 0, 0, 0, 7400, 7401, 10, 2, 0, 0, 7401, 7402, + 3, 704, 352, 0, 7402, 7403, 3, 692, 346, 3, 7403, 7412, 1, 0, 0, 0, 7404, + 7405, 10, 1, 0, 0, 7405, 7406, 3, 706, 353, 0, 7406, 7407, 3, 692, 346, + 2, 7407, 7412, 1, 0, 0, 0, 7408, 7409, 10, 14, 0, 0, 7409, 7410, 5, 27, + 0, 0, 7410, 7412, 3, 570, 285, 0, 7411, 7392, 1, 0, 0, 0, 7411, 7396, 1, + 0, 0, 0, 7411, 7400, 1, 0, 0, 0, 7411, 7404, 1, 0, 0, 0, 7411, 7408, 1, + 0, 0, 0, 7412, 7415, 1, 0, 0, 0, 7413, 7411, 1, 0, 0, 0, 7413, 7414, 1, + 0, 0, 0, 7414, 693, 1, 0, 0, 0, 7415, 7413, 1, 0, 0, 0, 7416, 7417, 7, + 134, 0, 0, 7417, 695, 1, 0, 0, 0, 7418, 7433, 5, 1129, 0, 0, 7419, 7433, + 5, 1130, 0, 0, 7420, 7433, 5, 1131, 0, 0, 7421, 7422, 5, 1131, 0, 0, 7422, + 7433, 5, 1129, 0, 0, 7423, 7424, 5, 1130, 0, 0, 7424, 7433, 5, 1129, 0, + 0, 7425, 7426, 5, 1131, 0, 0, 7426, 7433, 5, 1130, 0, 0, 7427, 7428, 5, + 1132, 0, 0, 7428, 7433, 5, 1129, 0, 0, 7429, 7430, 5, 1131, 0, 0, 7430, + 7431, 5, 1129, 0, 0, 7431, 7433, 5, 1130, 0, 0, 7432, 7418, 1, 0, 0, 0, + 7432, 7419, 1, 0, 0, 0, 7432, 7420, 1, 0, 0, 0, 7432, 7421, 1, 0, 0, 0, + 7432, 7423, 1, 0, 0, 0, 7432, 7425, 1, 0, 0, 0, 7432, 7427, 1, 0, 0, 0, + 7432, 7429, 1, 0, 0, 0, 7433, 697, 1, 0, 0, 0, 7434, 7442, 5, 10, 0, 0, + 7435, 7436, 5, 1135, 0, 0, 7436, 7442, 5, 1135, 0, 0, 7437, 7442, 5, 194, + 0, 0, 7438, 7442, 5, 123, 0, 0, 7439, 7440, 5, 1134, 0, 0, 7440, 7442, + 5, 1134, 0, 0, 7441, 7434, 1, 0, 0, 0, 7441, 7435, 1, 0, 0, 0, 7441, 7437, + 1, 0, 0, 0, 7441, 7438, 1, 0, 0, 0, 7441, 7439, 1, 0, 0, 0, 7442, 699, + 1, 0, 0, 0, 7443, 7444, 5, 1131, 0, 0, 7444, 7451, 5, 1131, 0, 0, 7445, + 7446, 5, 1130, 0, 0, 7446, 7451, 5, 1130, 0, 0, 7447, 7451, 5, 1135, 0, + 0, 7448, 7451, 5, 1136, 0, 0, 7449, 7451, 5, 1134, 0, 0, 7450, 7443, 1, + 0, 0, 0, 7450, 7445, 1, 0, 0, 0, 7450, 7447, 1, 0, 0, 0, 7450, 7448, 1, + 0, 0, 0, 7450, 7449, 1, 0, 0, 0, 7451, 701, 1, 0, 0, 0, 7452, 7453, 7, + 135, 0, 0, 7453, 703, 1, 0, 0, 0, 7454, 7455, 7, 136, 0, 0, 7455, 705, + 1, 0, 0, 0, 7456, 7457, 5, 1126, 0, 0, 7457, 7462, 5, 1130, 0, 0, 7458, + 7459, 5, 1126, 0, 0, 7459, 7460, 5, 1130, 0, 0, 7460, 7462, 5, 1130, 0, + 0, 7461, 7456, 1, 0, 0, 0, 7461, 7458, 1, 0, 0, 0, 7462, 707, 1, 0, 0, + 0, 7463, 7464, 7, 137, 0, 0, 7464, 709, 1, 0, 0, 0, 7465, 7466, 7, 138, + 0, 0, 7466, 711, 1, 0, 0, 0, 7467, 7468, 7, 139, 0, 0, 7468, 713, 1, 0, + 0, 0, 7469, 7470, 7, 140, 0, 0, 7470, 715, 1, 0, 0, 0, 7471, 7472, 7, 141, + 0, 0, 7472, 717, 1, 0, 0, 0, 7473, 7474, 7, 142, 0, 0, 7474, 719, 1, 0, + 0, 0, 7475, 7476, 7, 143, 0, 0, 7476, 721, 1, 0, 0, 0, 1095, 723, 727, + 734, 737, 740, 742, 748, 751, 754, 763, 805, 820, 831, 848, 853, 868, 895, + 904, 909, 915, 920, 924, 933, 936, 939, 943, 950, 953, 958, 966, 971, 976, + 979, 981, 993, 996, 1000, 1003, 1007, 1010, 1014, 1017, 1020, 1024, 1027, + 1031, 1037, 1043, 1049, 1056, 1063, 1066, 1070, 1075, 1081, 1090, 1095, + 1100, 1107, 1124, 1131, 1135, 1145, 1149, 1153, 1157, 1161, 1166, 1169, + 1172, 1175, 1178, 1184, 1188, 1194, 1199, 1202, 1205, 1207, 1218, 1222, + 1225, 1239, 1242, 1246, 1249, 1253, 1256, 1260, 1263, 1267, 1270, 1273, + 1277, 1280, 1284, 1290, 1294, 1306, 1312, 1323, 1328, 1336, 1344, 1349, + 1352, 1357, 1365, 1370, 1376, 1381, 1385, 1387, 1390, 1394, 1398, 1401, + 1405, 1409, 1413, 1419, 1422, 1429, 1434, 1440, 1447, 1453, 1461, 1464, + 1471, 1474, 1476, 1482, 1488, 1505, 1512, 1519, 1531, 1536, 1539, 1542, + 1555, 1568, 1573, 1589, 1597, 1607, 1610, 1613, 1619, 1623, 1626, 1637, + 1640, 1645, 1658, 1665, 1672, 1674, 1681, 1685, 1687, 1692, 1695, 1701, + 1706, 1708, 1712, 1715, 1718, 1724, 1729, 1731, 1736, 1743, 1745, 1752, + 1757, 1761, 1764, 1772, 1780, 1782, 1792, 1796, 1799, 1805, 1810, 1813, + 1819, 1822, 1826, 1829, 1833, 1838, 1843, 1848, 1852, 1856, 1860, 1864, + 1868, 1872, 1877, 1882, 1887, 1893, 1898, 1903, 1908, 1913, 1918, 1924, + 1929, 1934, 1939, 1944, 1949, 1954, 1959, 1966, 1971, 1976, 1981, 1985, + 1990, 1998, 2003, 2009, 2021, 2028, 2030, 2038, 2043, 2046, 2054, 2060, + 2064, 2077, 2089, 2091, 2094, 2102, 2108, 2114, 2127, 2134, 2143, 2148, + 2159, 2168, 2173, 2185, 2192, 2201, 2206, 2218, 2225, 2234, 2239, 2246, + 2255, 2260, 2262, 2267, 2275, 2284, 2288, 2291, 2295, 2300, 2306, 2312, + 2317, 2322, 2327, 2332, 2335, 2340, 2345, 2355, 2359, 2366, 2371, 2374, + 2379, 2382, 2386, 2390, 2398, 2417, 2420, 2423, 2427, 2437, 2450, 2457, + 2460, 2465, 2472, 2475, 2478, 2489, 2492, 2496, 2504, 2507, 2512, 2520, + 2526, 2530, 2534, 2539, 2544, 2551, 2555, 2566, 2574, 2577, 2583, 2589, + 2591, 2596, 2599, 2605, 2611, 2613, 2617, 2620, 2623, 2629, 2635, 2638, + 2644, 2650, 2652, 2657, 2665, 2667, 2676, 2679, 2682, 2687, 2689, 2698, + 2701, 2704, 2709, 2711, 2720, 2725, 2733, 2737, 2745, 2755, 2760, 2767, + 2771, 2775, 2794, 2804, 2810, 2827, 2831, 2841, 2846, 2849, 2858, 2869, + 2877, 2883, 2893, 2905, 2912, 2919, 2934, 2947, 2953, 2959, 2965, 2971, + 2977, 2983, 2988, 2995, 3002, 3009, 3014, 3017, 3019, 3033, 3040, 3047, + 3053, 3057, 3061, 3068, 3071, 3076, 3083, 3090, 3094, 3099, 3106, 3119, + 3122, 3127, 3132, 3136, 3142, 3151, 3160, 3169, 3172, 3176, 3185, 3189, + 3192, 3195, 3201, 3204, 3208, 3211, 3215, 3218, 3226, 3229, 3240, 3243, + 3248, 3251, 3256, 3266, 3271, 3277, 3279, 3285, 3287, 3293, 3301, 3306, + 3314, 3317, 3322, 3325, 3330, 3338, 3346, 3352, 3360, 3365, 3373, 3376, + 3380, 3383, 3391, 3397, 3406, 3409, 3413, 3417, 3421, 3426, 3430, 3434, + 3436, 3439, 3442, 3445, 3451, 3455, 3458, 3461, 3464, 3467, 3474, 3476, + 3480, 3485, 3491, 3496, 3503, 3509, 3514, 3517, 3523, 3527, 3535, 3539, + 3542, 3545, 3550, 3553, 3560, 3564, 3567, 3571, 3575, 3578, 3581, 3586, + 3592, 3596, 3606, 3612, 3616, 3622, 3626, 3632, 3635, 3647, 3651, 3655, + 3663, 3667, 3675, 3678, 3682, 3685, 3693, 3698, 3701, 3704, 3708, 3711, + 3720, 3725, 3734, 3739, 3746, 3753, 3761, 3767, 3775, 3778, 3781, 3788, + 3791, 3798, 3801, 3809, 3815, 3826, 3829, 3833, 3839, 3848, 3853, 3857, + 3863, 3869, 3871, 3875, 3884, 3894, 3904, 3910, 3915, 3919, 3922, 3925, + 3928, 3931, 3937, 3943, 3946, 3949, 3952, 3955, 3958, 3960, 3966, 3972, + 3975, 3978, 3981, 3984, 3987, 3991, 3997, 4001, 4009, 4013, 4016, 4018, + 4031, 4034, 4041, 4051, 4054, 4059, 4061, 4065, 4073, 4079, 4088, 4101, + 4105, 4111, 4120, 4123, 4127, 4130, 4134, 4138, 4141, 4143, 4151, 4163, + 4169, 4171, 4177, 4179, 4181, 4187, 4195, 4203, 4207, 4211, 4220, 4225, + 4245, 4250, 4256, 4263, 4268, 4277, 4280, 4284, 4288, 4292, 4295, 4298, + 4301, 4305, 4309, 4312, 4315, 4318, 4325, 4329, 4344, 4348, 4360, 4368, + 4378, 4382, 4385, 4391, 4394, 4397, 4406, 4415, 4425, 4429, 4439, 4449, + 4457, 4460, 4469, 4472, 4476, 4481, 4485, 4494, 4497, 4528, 4531, 4534, + 4590, 4595, 4623, 4637, 4644, 4648, 4654, 4662, 4664, 4675, 4685, 4692, + 4698, 4706, 4711, 4719, 4727, 4735, 4743, 4749, 4754, 4759, 4764, 4770, + 4772, 4783, 4788, 4795, 4797, 4811, 4817, 4822, 4827, 4833, 4840, 4848, + 4856, 4861, 4867, 4870, 4878, 4885, 4894, 4897, 4914, 4922, 4930, 4934, + 4941, 4947, 4955, 4964, 4970, 4977, 4984, 4989, 4992, 4994, 5000, 5002, + 5006, 5008, 5015, 5020, 5024, 5030, 5039, 5045, 5052, 5058, 5064, 5069, + 5072, 5074, 5080, 5082, 5086, 5088, 5095, 5097, 5102, 5109, 5118, 5123, + 5132, 5139, 5144, 5147, 5149, 5155, 5157, 5160, 5168, 5173, 5178, 5182, + 5188, 5193, 5197, 5203, 5205, 5216, 5219, 5226, 5229, 5241, 5247, 5256, + 5261, 5265, 5270, 5272, 5277, 5286, 5292, 5296, 5300, 5311, 5317, 5321, + 5325, 5330, 5334, 5340, 5345, 5349, 5355, 5357, 5369, 5376, 5381, 5411, + 5415, 5420, 5427, 5430, 5436, 5446, 5456, 5466, 5472, 5481, 5487, 5494, + 5496, 5506, 5510, 5514, 5524, 5529, 5601, 5619, 5627, 5639, 5646, 5648, + 5658, 5661, 5669, 5676, 5680, 5687, 5692, 5695, 5698, 5707, 5711, 5715, + 5738, 5745, 5749, 5756, 5763, 5766, 5782, 5785, 5795, 5799, 5805, 5808, + 5813, 5817, 5824, 5827, 5833, 5857, 5860, 5872, 5875, 5885, 5893, 5897, + 5904, 5907, 5916, 5922, 5928, 5938, 5940, 5946, 5949, 5952, 5964, 5967, + 5973, 5976, 5984, 5992, 5998, 6002, 6016, 6028, 6035, 6038, 6045, 6052, + 6057, 6070, 6081, 6087, 6092, 6105, 6107, 6112, 6116, 6119, 6121, 6128, + 6135, 6138, 6141, 6147, 6151, 6157, 6163, 6176, 6181, 6189, 6192, 6197, + 6202, 6210, 6213, 6221, 6225, 6232, 6238, 6241, 6245, 6258, 6264, 6276, + 6279, 6288, 6293, 6299, 6305, 6310, 6312, 6315, 6319, 6321, 6325, 6331, + 6334, 6337, 6343, 6352, 6360, 6364, 6369, 6389, 6396, 6398, 6405, 6407, + 6411, 6416, 6427, 6432, 6438, 6441, 6445, 6450, 6453, 6457, 6461, 6463, + 6468, 6473, 6486, 6489, 6493, 6496, 6499, 6504, 6509, 6515, 6518, 6523, + 6526, 6531, 6534, 6538, 6543, 6548, 6553, 6558, 6561, 6566, 6571, 6576, + 6582, 6587, 6592, 6597, 6601, 6604, 6609, 6613, 6617, 6625, 6632, 6636, + 6641, 6646, 6650, 6652, 6655, 6671, 6680, 6688, 6696, 6705, 6715, 6723, + 6731, 6739, 6747, 6759, 6766, 6776, 6781, 6784, 6789, 6792, 6796, 6811, + 6819, 6826, 6831, 6836, 6870, 6874, 6882, 6886, 6895, 6903, 6908, 6916, + 6921, 6926, 6928, 6937, 6942, 6950, 6955, 6963, 6971, 6974, 6984, 7002, + 7005, 7008, 7012, 7025, 7033, 7037, 7042, 7047, 7053, 7058, 7062, 7067, + 7072, 7077, 7087, 7090, 7094, 7098, 7105, 7109, 7138, 7146, 7149, 7152, + 7155, 7158, 7169, 7183, 7192, 7219, 7230, 7237, 7241, 7248, 7256, 7261, + 7269, 7281, 7294, 7300, 7306, 7322, 7328, 7337, 7339, 7361, 7373, 7390, + 7411, 7413, 7432, 7441, 7450, 7461, + } + deserializer := antlr.NewATNDeserializer(nil) + staticData.atn = deserializer.Deserialize(staticData.serializedATN) + atn := staticData.atn + staticData.decisionToDFA = make([]*antlr.DFA, len(atn.DecisionToState)) + decisionToDFA := staticData.decisionToDFA + for index, state := range atn.DecisionToState { + decisionToDFA[index] = antlr.NewDFA(state, index) + } +} + +// MySqlParserInit initializes any static state used to implement MySqlParser. By default the +// static state used to implement the parser is lazily initialized during the first call to +// NewMySqlParser(). You can call this function if you wish to initialize the static state ahead +// of time. +func MySqlParserInit() { + staticData := &MySqlParserParserStaticData + staticData.once.Do(mysqlparserParserInit) +} + +// NewMySqlParser produces a new parser instance for the optional input antlr.TokenStream. +func NewMySqlParser(input antlr.TokenStream) *MySqlParser { + MySqlParserInit() + this := new(MySqlParser) + this.BaseParser = antlr.NewBaseParser(input) + staticData := &MySqlParserParserStaticData + this.Interpreter = antlr.NewParserATNSimulator(this, staticData.atn, staticData.decisionToDFA, staticData.PredictionContextCache) + this.RuleNames = staticData.RuleNames + this.LiteralNames = staticData.LiteralNames + this.SymbolicNames = staticData.SymbolicNames + this.GrammarFileName = "MySqlParser.g4" + + return this +} + +// MySqlParser tokens. +const ( + MySqlParserEOF = antlr.TokenEOF + MySqlParserSPACE = 1 + MySqlParserSPEC_MYSQL_COMMENT = 2 + MySqlParserCOMMENT_INPUT = 3 + MySqlParserLINE_COMMENT = 4 + MySqlParserADD = 5 + MySqlParserALL = 6 + MySqlParserALTER = 7 + MySqlParserALWAYS = 8 + MySqlParserANALYZE = 9 + MySqlParserAND = 10 + MySqlParserARRAY = 11 + MySqlParserAS = 12 + MySqlParserASC = 13 + MySqlParserATTRIBUTE = 14 + MySqlParserBEFORE = 15 + MySqlParserBETWEEN = 16 + MySqlParserBOTH = 17 + MySqlParserBUCKETS = 18 + MySqlParserBY = 19 + MySqlParserCALL = 20 + MySqlParserCASCADE = 21 + MySqlParserCASE = 22 + MySqlParserCAST = 23 + MySqlParserCHANGE = 24 + MySqlParserCHARACTER = 25 + MySqlParserCHECK = 26 + MySqlParserCOLLATE = 27 + MySqlParserCOLUMN = 28 + MySqlParserCONDITION = 29 + MySqlParserCONSTRAINT = 30 + MySqlParserCONTINUE = 31 + MySqlParserCONVERT = 32 + MySqlParserCREATE = 33 + MySqlParserCROSS = 34 + MySqlParserCURRENT = 35 + MySqlParserCURRENT_ROLE = 36 + MySqlParserCURRENT_USER = 37 + MySqlParserCURSOR = 38 + MySqlParserDATABASE = 39 + MySqlParserDATABASES = 40 + MySqlParserDECLARE = 41 + MySqlParserDEFAULT = 42 + MySqlParserDELAYED = 43 + MySqlParserDELETE = 44 + MySqlParserDESC = 45 + MySqlParserDESCRIBE = 46 + MySqlParserDETERMINISTIC = 47 + MySqlParserDIAGNOSTICS = 48 + MySqlParserDISTINCT = 49 + MySqlParserDISTINCTROW = 50 + MySqlParserDROP = 51 + MySqlParserEACH = 52 + MySqlParserELSE = 53 + MySqlParserELSEIF = 54 + MySqlParserEMPTY = 55 + MySqlParserENCLOSED = 56 + MySqlParserENFORCED = 57 + MySqlParserESCAPED = 58 + MySqlParserEXCEPT = 59 + MySqlParserEXISTS = 60 + MySqlParserEXIT = 61 + MySqlParserEXPLAIN = 62 + MySqlParserFALSE = 63 + MySqlParserFETCH = 64 + MySqlParserFOR = 65 + MySqlParserFORCE = 66 + MySqlParserFOREIGN = 67 + MySqlParserFROM = 68 + MySqlParserFULLTEXT = 69 + MySqlParserGENERATED = 70 + MySqlParserGET = 71 + MySqlParserGRANT = 72 + MySqlParserGROUP = 73 + MySqlParserHAVING = 74 + MySqlParserHIGH_PRIORITY = 75 + MySqlParserHISTOGRAM = 76 + MySqlParserIF = 77 + MySqlParserIGNORE = 78 + MySqlParserIGNORED = 79 + MySqlParserIN = 80 + MySqlParserINDEX = 81 + MySqlParserINFILE = 82 + MySqlParserINNER = 83 + MySqlParserINOUT = 84 + MySqlParserINSERT = 85 + MySqlParserINTERVAL = 86 + MySqlParserINTO = 87 + MySqlParserIS = 88 + MySqlParserITERATE = 89 + MySqlParserJOIN = 90 + MySqlParserKEY = 91 + MySqlParserKEYS = 92 + MySqlParserKILL = 93 + MySqlParserLATERAL = 94 + MySqlParserLEADING = 95 + MySqlParserLEAVE = 96 + MySqlParserLEFT = 97 + MySqlParserLIKE = 98 + MySqlParserLIMIT = 99 + MySqlParserLINEAR = 100 + MySqlParserLINES = 101 + MySqlParserLOAD = 102 + MySqlParserLOCK = 103 + MySqlParserLOCKED = 104 + MySqlParserLOOP = 105 + MySqlParserLOW_PRIORITY = 106 + MySqlParserMASTER_BIND = 107 + MySqlParserMASTER_SSL_VERIFY_SERVER_CERT = 108 + MySqlParserMATCH = 109 + MySqlParserMAXVALUE = 110 + MySqlParserMINVALUE = 111 + MySqlParserMODIFIES = 112 + MySqlParserNATURAL = 113 + MySqlParserNOT = 114 + MySqlParserNO_WRITE_TO_BINLOG = 115 + MySqlParserNULL_LITERAL = 116 + MySqlParserNUMBER = 117 + MySqlParserON = 118 + MySqlParserOPTIMIZE = 119 + MySqlParserOPTION = 120 + MySqlParserOPTIONAL = 121 + MySqlParserOPTIONALLY = 122 + MySqlParserOR = 123 + MySqlParserORDER = 124 + MySqlParserOUT = 125 + MySqlParserOUTER = 126 + MySqlParserOUTFILE = 127 + MySqlParserOVER = 128 + MySqlParserPARTITION = 129 + MySqlParserPRIMARY = 130 + MySqlParserPROCEDURE = 131 + MySqlParserPURGE = 132 + MySqlParserRANGE = 133 + MySqlParserREAD = 134 + MySqlParserREADS = 135 + MySqlParserREFERENCES = 136 + MySqlParserREGEXP = 137 + MySqlParserRELEASE = 138 + MySqlParserRENAME = 139 + MySqlParserREPEAT = 140 + MySqlParserREPLACE = 141 + MySqlParserREQUIRE = 142 + MySqlParserRESIGNAL = 143 + MySqlParserRESTRICT = 144 + MySqlParserRETAIN = 145 + MySqlParserRETURN = 146 + MySqlParserREVOKE = 147 + MySqlParserRIGHT = 148 + MySqlParserRLIKE = 149 + MySqlParserSCHEMA = 150 + MySqlParserSCHEMAS = 151 + MySqlParserSELECT = 152 + MySqlParserSET = 153 + MySqlParserSEPARATOR = 154 + MySqlParserSHOW = 155 + MySqlParserSIGNAL = 156 + MySqlParserSKIP_ = 157 + MySqlParserSKIP_QUERY_REWRITE = 158 + MySqlParserSPATIAL = 159 + MySqlParserSQL = 160 + MySqlParserSQLEXCEPTION = 161 + MySqlParserSQLSTATE = 162 + MySqlParserSQLWARNING = 163 + MySqlParserSQL_BIG_RESULT = 164 + MySqlParserSQL_CALC_FOUND_ROWS = 165 + MySqlParserSQL_SMALL_RESULT = 166 + MySqlParserSSL = 167 + MySqlParserSTACKED = 168 + MySqlParserSTARTING = 169 + MySqlParserSTATEMENT = 170 + MySqlParserSTRAIGHT_JOIN = 171 + MySqlParserTABLE = 172 + MySqlParserTERMINATED = 173 + MySqlParserTHEN = 174 + MySqlParserTO = 175 + MySqlParserTRAILING = 176 + MySqlParserTRIGGER = 177 + MySqlParserTRUE = 178 + MySqlParserUNDO = 179 + MySqlParserUNION = 180 + MySqlParserUNIQUE = 181 + MySqlParserUNLOCK = 182 + MySqlParserUNSIGNED = 183 + MySqlParserUPDATE = 184 + MySqlParserUSAGE = 185 + MySqlParserUSE = 186 + MySqlParserUSING = 187 + MySqlParserVALUES = 188 + MySqlParserWHEN = 189 + MySqlParserWHERE = 190 + MySqlParserWHILE = 191 + MySqlParserWITH = 192 + MySqlParserWRITE = 193 + MySqlParserXOR = 194 + MySqlParserZEROFILL = 195 + MySqlParserTINYINT = 196 + MySqlParserSMALLINT = 197 + MySqlParserMEDIUMINT = 198 + MySqlParserMIDDLEINT = 199 + MySqlParserINT = 200 + MySqlParserINT1 = 201 + MySqlParserINT2 = 202 + MySqlParserINT3 = 203 + MySqlParserINT4 = 204 + MySqlParserINT8 = 205 + MySqlParserINTEGER = 206 + MySqlParserBIGINT = 207 + MySqlParserREAL = 208 + MySqlParserDOUBLE = 209 + MySqlParserPRECISION = 210 + MySqlParserFLOAT = 211 + MySqlParserFLOAT4 = 212 + MySqlParserFLOAT8 = 213 + MySqlParserDECIMAL = 214 + MySqlParserDEC = 215 + MySqlParserNUMERIC = 216 + MySqlParserDATE = 217 + MySqlParserTIME = 218 + MySqlParserTIMESTAMP = 219 + MySqlParserDATETIME = 220 + MySqlParserYEAR = 221 + MySqlParserCHAR = 222 + MySqlParserVARCHAR = 223 + MySqlParserNVARCHAR = 224 + MySqlParserNATIONAL = 225 + MySqlParserBINARY = 226 + MySqlParserVARBINARY = 227 + MySqlParserTINYBLOB = 228 + MySqlParserBLOB = 229 + MySqlParserMEDIUMBLOB = 230 + MySqlParserLONG = 231 + MySqlParserLONGBLOB = 232 + MySqlParserTINYTEXT = 233 + MySqlParserTEXT = 234 + MySqlParserMEDIUMTEXT = 235 + MySqlParserLONGTEXT = 236 + MySqlParserENUM = 237 + MySqlParserVARYING = 238 + MySqlParserSERIAL = 239 + MySqlParserVECTOR = 240 + MySqlParserYEAR_MONTH = 241 + MySqlParserDAY_HOUR = 242 + MySqlParserDAY_MINUTE = 243 + MySqlParserDAY_SECOND = 244 + MySqlParserHOUR_MINUTE = 245 + MySqlParserHOUR_SECOND = 246 + MySqlParserMINUTE_SECOND = 247 + MySqlParserSECOND_MICROSECOND = 248 + MySqlParserMINUTE_MICROSECOND = 249 + MySqlParserHOUR_MICROSECOND = 250 + MySqlParserDAY_MICROSECOND = 251 + MySqlParserJSON_ARRAY = 252 + MySqlParserJSON_ARRAYAGG = 253 + MySqlParserJSON_ARRAY_APPEND = 254 + MySqlParserJSON_ARRAY_INSERT = 255 + MySqlParserJSON_CONTAINS = 256 + MySqlParserJSON_CONTAINS_PATH = 257 + MySqlParserJSON_DEPTH = 258 + MySqlParserJSON_EXTRACT = 259 + MySqlParserJSON_INSERT = 260 + MySqlParserJSON_KEYS = 261 + MySqlParserJSON_LENGTH = 262 + MySqlParserJSON_MERGE = 263 + MySqlParserJSON_MERGE_PATCH = 264 + MySqlParserJSON_MERGE_PRESERVE = 265 + MySqlParserJSON_OBJECT = 266 + MySqlParserJSON_OBJECTAGG = 267 + MySqlParserJSON_OVERLAPS = 268 + MySqlParserJSON_PRETTY = 269 + MySqlParserJSON_QUOTE = 270 + MySqlParserJSON_REMOVE = 271 + MySqlParserJSON_REPLACE = 272 + MySqlParserJSON_SCHEMA_VALID = 273 + MySqlParserJSON_SCHEMA_VALIDATION_REPORT = 274 + MySqlParserJSON_SEARCH = 275 + MySqlParserJSON_SET = 276 + MySqlParserJSON_STORAGE_FREE = 277 + MySqlParserJSON_STORAGE_SIZE = 278 + MySqlParserJSON_TABLE = 279 + MySqlParserJSON_TYPE = 280 + MySqlParserJSON_UNQUOTE = 281 + MySqlParserJSON_VALID = 282 + MySqlParserJSON_VALUE = 283 + MySqlParserNESTED = 284 + MySqlParserORDINALITY = 285 + MySqlParserPATH = 286 + MySqlParserAVG = 287 + MySqlParserBIT_AND = 288 + MySqlParserBIT_OR = 289 + MySqlParserBIT_XOR = 290 + MySqlParserCOUNT = 291 + MySqlParserCUME_DIST = 292 + MySqlParserDENSE_RANK = 293 + MySqlParserFIRST_VALUE = 294 + MySqlParserGROUP_CONCAT = 295 + MySqlParserLAG = 296 + MySqlParserLAST_VALUE = 297 + MySqlParserLEAD = 298 + MySqlParserMAX = 299 + MySqlParserMIN = 300 + MySqlParserNTILE = 301 + MySqlParserNTH_VALUE = 302 + MySqlParserPERCENT_RANK = 303 + MySqlParserRANK = 304 + MySqlParserROW_NUMBER = 305 + MySqlParserSTD = 306 + MySqlParserSTDDEV = 307 + MySqlParserSTDDEV_POP = 308 + MySqlParserSTDDEV_SAMP = 309 + MySqlParserSUM = 310 + MySqlParserVAR_POP = 311 + MySqlParserVAR_SAMP = 312 + MySqlParserVARIANCE = 313 + MySqlParserCURRENT_DATE = 314 + MySqlParserCURRENT_TIME = 315 + MySqlParserCURRENT_TIMESTAMP = 316 + MySqlParserLOCALTIME = 317 + MySqlParserCURDATE = 318 + MySqlParserCURTIME = 319 + MySqlParserDATE_ADD = 320 + MySqlParserDATE_SUB = 321 + MySqlParserEXTRACT = 322 + MySqlParserLOCALTIMESTAMP = 323 + MySqlParserNOW = 324 + MySqlParserPOSITION = 325 + MySqlParserSUBSTR = 326 + MySqlParserSUBSTRING = 327 + MySqlParserSYSDATE = 328 + MySqlParserTRIM = 329 + MySqlParserUTC_DATE = 330 + MySqlParserUTC_TIME = 331 + MySqlParserUTC_TIMESTAMP = 332 + MySqlParserACCOUNT = 333 + MySqlParserACTION = 334 + MySqlParserAFTER = 335 + MySqlParserAGGREGATE = 336 + MySqlParserALGORITHM = 337 + MySqlParserANY = 338 + MySqlParserAT = 339 + MySqlParserAUTHORS = 340 + MySqlParserAUTOCOMMIT = 341 + MySqlParserAUTOEXTEND_SIZE = 342 + MySqlParserAUTO_INCREMENT = 343 + MySqlParserAVG_ROW_LENGTH = 344 + MySqlParserBEGIN = 345 + MySqlParserBINLOG = 346 + MySqlParserBIT = 347 + MySqlParserBLOCK = 348 + MySqlParserBOOL = 349 + MySqlParserBOOLEAN = 350 + MySqlParserBTREE = 351 + MySqlParserCACHE = 352 + MySqlParserCASCADED = 353 + MySqlParserCHAIN = 354 + MySqlParserCHANGED = 355 + MySqlParserCHANNEL = 356 + MySqlParserCHECKSUM = 357 + MySqlParserPAGE_CHECKSUM = 358 + MySqlParserCIPHER = 359 + MySqlParserCLASS_ORIGIN = 360 + MySqlParserCLIENT = 361 + MySqlParserCLOSE = 362 + MySqlParserCLUSTERING = 363 + MySqlParserCOALESCE = 364 + MySqlParserCODE = 365 + MySqlParserCOLUMNS = 366 + MySqlParserCOLUMN_FORMAT = 367 + MySqlParserCOLUMN_NAME = 368 + MySqlParserCOMMENT = 369 + MySqlParserCOMMIT = 370 + MySqlParserCOMPACT = 371 + MySqlParserCOMPLETION = 372 + MySqlParserCOMPRESSED = 373 + MySqlParserCOMPRESSION = 374 + MySqlParserCONCURRENT = 375 + MySqlParserCONNECT = 376 + MySqlParserCONNECTION = 377 + MySqlParserCONSISTENT = 378 + MySqlParserCONSTRAINT_CATALOG = 379 + MySqlParserCONSTRAINT_SCHEMA = 380 + MySqlParserCONSTRAINT_NAME = 381 + MySqlParserCONTAINS = 382 + MySqlParserCONTEXT = 383 + MySqlParserCONTRIBUTORS = 384 + MySqlParserCOPY = 385 + MySqlParserCPU = 386 + MySqlParserCYCLE = 387 + MySqlParserCURSOR_NAME = 388 + MySqlParserDATA = 389 + MySqlParserDATAFILE = 390 + MySqlParserDEALLOCATE = 391 + MySqlParserDEFAULT_AUTH = 392 + MySqlParserDEFINER = 393 + MySqlParserDELAY_KEY_WRITE = 394 + MySqlParserDES_KEY_FILE = 395 + MySqlParserDIRECTORY = 396 + MySqlParserDISABLE = 397 + MySqlParserDISCARD = 398 + MySqlParserDISK = 399 + MySqlParserDO = 400 + MySqlParserDUMPFILE = 401 + MySqlParserDUPLICATE = 402 + MySqlParserDYNAMIC = 403 + MySqlParserENABLE = 404 + MySqlParserENCRYPTED = 405 + MySqlParserENCRYPTION = 406 + MySqlParserENCRYPTION_KEY_ID = 407 + MySqlParserEND = 408 + MySqlParserENDS = 409 + MySqlParserENGINE = 410 + MySqlParserENGINES = 411 + MySqlParserERROR = 412 + MySqlParserERRORS = 413 + MySqlParserESCAPE = 414 + MySqlParserEVEN = 415 + MySqlParserEVENT = 416 + MySqlParserEVENTS = 417 + MySqlParserEVERY = 418 + MySqlParserEXCHANGE = 419 + MySqlParserEXCLUSIVE = 420 + MySqlParserEXPIRE = 421 + MySqlParserEXPORT = 422 + MySqlParserEXTENDED = 423 + MySqlParserEXTENT_SIZE = 424 + MySqlParserFAILED_LOGIN_ATTEMPTS = 425 + MySqlParserFAST = 426 + MySqlParserFAULTS = 427 + MySqlParserFIELDS = 428 + MySqlParserFILE_BLOCK_SIZE = 429 + MySqlParserFILTER = 430 + MySqlParserFIRST = 431 + MySqlParserFIXED = 432 + MySqlParserFLUSH = 433 + MySqlParserFOLLOWING = 434 + MySqlParserFOLLOWS = 435 + MySqlParserFOUND = 436 + MySqlParserFULL = 437 + MySqlParserFUNCTION = 438 + MySqlParserGENERAL = 439 + MySqlParserGLOBAL = 440 + MySqlParserGRANTS = 441 + MySqlParserGROUP_REPLICATION = 442 + MySqlParserHANDLER = 443 + MySqlParserHASH = 444 + MySqlParserHELP = 445 + MySqlParserHISTORY = 446 + MySqlParserHOST = 447 + MySqlParserHOSTS = 448 + MySqlParserIDENTIFIED = 449 + MySqlParserIGNORE_SERVER_IDS = 450 + MySqlParserIMPORT = 451 + MySqlParserINCREMENT = 452 + MySqlParserINDEXES = 453 + MySqlParserINITIAL_SIZE = 454 + MySqlParserINPLACE = 455 + MySqlParserINSERT_METHOD = 456 + MySqlParserINSTALL = 457 + MySqlParserINSTANCE = 458 + MySqlParserINSTANT = 459 + MySqlParserINVISIBLE = 460 + MySqlParserINVOKER = 461 + MySqlParserIO = 462 + MySqlParserIO_THREAD = 463 + MySqlParserIPC = 464 + MySqlParserISOLATION = 465 + MySqlParserISSUER = 466 + MySqlParserJSON = 467 + MySqlParserKEY_BLOCK_SIZE = 468 + MySqlParserLANGUAGE = 469 + MySqlParserLAST = 470 + MySqlParserLEAVES = 471 + MySqlParserLESS = 472 + MySqlParserLEVEL = 473 + MySqlParserLIST = 474 + MySqlParserLOCAL = 475 + MySqlParserLOGFILE = 476 + MySqlParserLOGS = 477 + MySqlParserMASTER = 478 + MySqlParserMASTER_AUTO_POSITION = 479 + MySqlParserMASTER_CONNECT_RETRY = 480 + MySqlParserMASTER_DELAY = 481 + MySqlParserMASTER_HEARTBEAT_PERIOD = 482 + MySqlParserMASTER_HOST = 483 + MySqlParserMASTER_LOG_FILE = 484 + MySqlParserMASTER_LOG_POS = 485 + MySqlParserMASTER_PASSWORD = 486 + MySqlParserMASTER_PORT = 487 + MySqlParserMASTER_RETRY_COUNT = 488 + MySqlParserMASTER_SSL = 489 + MySqlParserMASTER_SSL_CA = 490 + MySqlParserMASTER_SSL_CAPATH = 491 + MySqlParserMASTER_SSL_CERT = 492 + MySqlParserMASTER_SSL_CIPHER = 493 + MySqlParserMASTER_SSL_CRL = 494 + MySqlParserMASTER_SSL_CRLPATH = 495 + MySqlParserMASTER_SSL_KEY = 496 + MySqlParserMASTER_TLS_VERSION = 497 + MySqlParserMASTER_USER = 498 + MySqlParserMAX_CONNECTIONS_PER_HOUR = 499 + MySqlParserMAX_QUERIES_PER_HOUR = 500 + MySqlParserMAX_ROWS = 501 + MySqlParserMAX_SIZE = 502 + MySqlParserMAX_UPDATES_PER_HOUR = 503 + MySqlParserMAX_USER_CONNECTIONS = 504 + MySqlParserMEDIUM = 505 + MySqlParserMEMBER = 506 + MySqlParserMERGE = 507 + MySqlParserMESSAGE_TEXT = 508 + MySqlParserMID = 509 + MySqlParserMIGRATE = 510 + MySqlParserMIN_ROWS = 511 + MySqlParserMODE = 512 + MySqlParserMODIFY = 513 + MySqlParserMUTEX = 514 + MySqlParserMYSQL = 515 + MySqlParserMYSQL_ERRNO = 516 + MySqlParserNAME = 517 + MySqlParserNAMES = 518 + MySqlParserNCHAR = 519 + MySqlParserNEVER = 520 + MySqlParserNEXT = 521 + MySqlParserNO = 522 + MySqlParserNOCACHE = 523 + MySqlParserNOCOPY = 524 + MySqlParserNOCYCLE = 525 + MySqlParserNOMAXVALUE = 526 + MySqlParserNOMINVALUE = 527 + MySqlParserNOWAIT = 528 + MySqlParserNODEGROUP = 529 + MySqlParserNONE = 530 + MySqlParserODBC = 531 + MySqlParserOFFLINE = 532 + MySqlParserOFFSET = 533 + MySqlParserOF = 534 + MySqlParserOJ = 535 + MySqlParserOLD_PASSWORD = 536 + MySqlParserONE = 537 + MySqlParserONLINE = 538 + MySqlParserONLY = 539 + MySqlParserOPEN = 540 + MySqlParserOPTIMIZER_COSTS = 541 + MySqlParserOPTIONS = 542 + MySqlParserOWNER = 543 + MySqlParserPACK_KEYS = 544 + MySqlParserPAGE = 545 + MySqlParserPAGE_COMPRESSED = 546 + MySqlParserPAGE_COMPRESSION_LEVEL = 547 + MySqlParserPARSER = 548 + MySqlParserPARTIAL = 549 + MySqlParserPARTITIONING = 550 + MySqlParserPARTITIONS = 551 + MySqlParserPASSWORD = 552 + MySqlParserPASSWORD_LOCK_TIME = 553 + MySqlParserPHASE = 554 + MySqlParserPLUGIN = 555 + MySqlParserPLUGIN_DIR = 556 + MySqlParserPLUGINS = 557 + MySqlParserPORT = 558 + MySqlParserPRECEDES = 559 + MySqlParserPRECEDING = 560 + MySqlParserPREPARE = 561 + MySqlParserPRESERVE = 562 + MySqlParserPREV = 563 + MySqlParserPROCESSLIST = 564 + MySqlParserPROFILE = 565 + MySqlParserPROFILES = 566 + MySqlParserPROXY = 567 + MySqlParserQUERY = 568 + MySqlParserQUICK = 569 + MySqlParserREBUILD = 570 + MySqlParserRECOVER = 571 + MySqlParserRECURSIVE = 572 + MySqlParserREDO_BUFFER_SIZE = 573 + MySqlParserREDUNDANT = 574 + MySqlParserRELAY = 575 + MySqlParserRELAY_LOG_FILE = 576 + MySqlParserRELAY_LOG_POS = 577 + MySqlParserRELAYLOG = 578 + MySqlParserREMOVE = 579 + MySqlParserREORGANIZE = 580 + MySqlParserREPAIR = 581 + MySqlParserREPLICATE_DO_DB = 582 + MySqlParserREPLICATE_DO_TABLE = 583 + MySqlParserREPLICATE_IGNORE_DB = 584 + MySqlParserREPLICATE_IGNORE_TABLE = 585 + MySqlParserREPLICATE_REWRITE_DB = 586 + MySqlParserREPLICATE_WILD_DO_TABLE = 587 + MySqlParserREPLICATE_WILD_IGNORE_TABLE = 588 + MySqlParserREPLICATION = 589 + MySqlParserRESET = 590 + MySqlParserRESTART = 591 + MySqlParserRESUME = 592 + MySqlParserRETURNED_SQLSTATE = 593 + MySqlParserRETURNING = 594 + MySqlParserRETURNS = 595 + MySqlParserREUSE = 596 + MySqlParserROLE = 597 + MySqlParserROLLBACK = 598 + MySqlParserROLLUP = 599 + MySqlParserROTATE = 600 + MySqlParserROW = 601 + MySqlParserROWS = 602 + MySqlParserROW_FORMAT = 603 + MySqlParserRTREE = 604 + MySqlParserSAVEPOINT = 605 + MySqlParserSCHEDULE = 606 + MySqlParserSECURITY = 607 + MySqlParserSEQUENCE = 608 + MySqlParserSERVER = 609 + MySqlParserSESSION = 610 + MySqlParserSHARE = 611 + MySqlParserSHARED = 612 + MySqlParserSIGNED = 613 + MySqlParserSIMPLE = 614 + MySqlParserSLAVE = 615 + MySqlParserSLOW = 616 + MySqlParserSNAPSHOT = 617 + MySqlParserSOCKET = 618 + MySqlParserSOME = 619 + MySqlParserSONAME = 620 + MySqlParserSOUNDS = 621 + MySqlParserSOURCE = 622 + MySqlParserSQL_AFTER_GTIDS = 623 + MySqlParserSQL_AFTER_MTS_GAPS = 624 + MySqlParserSQL_BEFORE_GTIDS = 625 + MySqlParserSQL_BUFFER_RESULT = 626 + MySqlParserSQL_CACHE = 627 + MySqlParserSQL_NO_CACHE = 628 + MySqlParserSQL_THREAD = 629 + MySqlParserSTART = 630 + MySqlParserSTARTS = 631 + MySqlParserSTATS_AUTO_RECALC = 632 + MySqlParserSTATS_PERSISTENT = 633 + MySqlParserSTATS_SAMPLE_PAGES = 634 + MySqlParserSTATUS = 635 + MySqlParserSTOP = 636 + MySqlParserSTORAGE = 637 + MySqlParserSTORED = 638 + MySqlParserSTRING = 639 + MySqlParserSUBCLASS_ORIGIN = 640 + MySqlParserSUBJECT = 641 + MySqlParserSUBPARTITION = 642 + MySqlParserSUBPARTITIONS = 643 + MySqlParserSUSPEND = 644 + MySqlParserSWAPS = 645 + MySqlParserSWITCHES = 646 + MySqlParserTABLE_NAME = 647 + MySqlParserTABLESPACE = 648 + MySqlParserTABLE_TYPE = 649 + MySqlParserTEMPORARY = 650 + MySqlParserTEMPTABLE = 651 + MySqlParserTHAN = 652 + MySqlParserTRADITIONAL = 653 + MySqlParserTRANSACTION = 654 + MySqlParserTRANSACTIONAL = 655 + MySqlParserTRIGGERS = 656 + MySqlParserTRUNCATE = 657 + MySqlParserUNBOUNDED = 658 + MySqlParserUNDEFINED = 659 + MySqlParserUNDOFILE = 660 + MySqlParserUNDO_BUFFER_SIZE = 661 + MySqlParserUNINSTALL = 662 + MySqlParserUNKNOWN = 663 + MySqlParserUNTIL = 664 + MySqlParserUPGRADE = 665 + MySqlParserUSER = 666 + MySqlParserUSE_FRM = 667 + MySqlParserUSER_RESOURCES = 668 + MySqlParserVALIDATION = 669 + MySqlParserVALUE = 670 + MySqlParserVARIABLES = 671 + MySqlParserVIEW = 672 + MySqlParserVIRTUAL = 673 + MySqlParserVISIBLE = 674 + MySqlParserWAIT = 675 + MySqlParserWARNINGS = 676 + MySqlParserWINDOW = 677 + MySqlParserWITHOUT = 678 + MySqlParserWORK = 679 + MySqlParserWRAPPER = 680 + MySqlParserX509 = 681 + MySqlParserXA = 682 + MySqlParserXML = 683 + MySqlParserYES = 684 + MySqlParserEUR = 685 + MySqlParserUSA = 686 + MySqlParserJIS = 687 + MySqlParserISO = 688 + MySqlParserINTERNAL = 689 + MySqlParserQUARTER = 690 + MySqlParserMONTH = 691 + MySqlParserDAY = 692 + MySqlParserHOUR = 693 + MySqlParserMINUTE = 694 + MySqlParserWEEK = 695 + MySqlParserSECOND = 696 + MySqlParserMICROSECOND = 697 + MySqlParserADMIN = 698 + MySqlParserAPPLICATION_PASSWORD_ADMIN = 699 + MySqlParserAUDIT_ABORT_EXEMPT = 700 + MySqlParserAUDIT_ADMIN = 701 + MySqlParserAUTHENTICATION_POLICY_ADMIN = 702 + MySqlParserBACKUP_ADMIN = 703 + MySqlParserBINLOG_ADMIN = 704 + MySqlParserBINLOG_ENCRYPTION_ADMIN = 705 + MySqlParserCLONE_ADMIN = 706 + MySqlParserCONNECTION_ADMIN = 707 + MySqlParserENCRYPTION_KEY_ADMIN = 708 + MySqlParserEXECUTE = 709 + MySqlParserFILE = 710 + MySqlParserFIREWALL_ADMIN = 711 + MySqlParserFIREWALL_EXEMPT = 712 + MySqlParserFIREWALL_USER = 713 + MySqlParserFLUSH_OPTIMIZER_COSTS = 714 + MySqlParserFLUSH_STATUS = 715 + MySqlParserFLUSH_TABLES = 716 + MySqlParserFLUSH_USER_RESOURCES = 717 + MySqlParserGROUP_REPLICATION_ADMIN = 718 + MySqlParserINNODB_REDO_LOG_ARCHIVE = 719 + MySqlParserINNODB_REDO_LOG_ENABLE = 720 + MySqlParserINVOKE = 721 + MySqlParserLAMBDA = 722 + MySqlParserNDB_STORED_USER = 723 + MySqlParserPASSWORDLESS_USER_ADMIN = 724 + MySqlParserPERSIST_RO_VARIABLES_ADMIN = 725 + MySqlParserPRIVILEGES = 726 + MySqlParserPROCESS = 727 + MySqlParserRELOAD = 728 + MySqlParserREPLICATION_APPLIER = 729 + MySqlParserREPLICATION_SLAVE_ADMIN = 730 + MySqlParserRESOURCE_GROUP_ADMIN = 731 + MySqlParserRESOURCE_GROUP_USER = 732 + MySqlParserROLE_ADMIN = 733 + MySqlParserROUTINE = 734 + MySqlParserS3 = 735 + MySqlParserSERVICE_CONNECTION_ADMIN = 736 + MySqlParserSESSION_VARIABLES_ADMIN = 737 + MySqlParserSET_USER_ID = 738 + MySqlParserSHOW_ROUTINE = 739 + MySqlParserSHUTDOWN = 740 + MySqlParserSUPER = 741 + MySqlParserSYSTEM_VARIABLES_ADMIN = 742 + MySqlParserTABLES = 743 + MySqlParserTABLE_ENCRYPTION_ADMIN = 744 + MySqlParserVERSION_TOKEN_ADMIN = 745 + MySqlParserXA_RECOVER_ADMIN = 746 + MySqlParserARMSCII8 = 747 + MySqlParserASCII = 748 + MySqlParserBIG5 = 749 + MySqlParserCP1250 = 750 + MySqlParserCP1251 = 751 + MySqlParserCP1256 = 752 + MySqlParserCP1257 = 753 + MySqlParserCP850 = 754 + MySqlParserCP852 = 755 + MySqlParserCP866 = 756 + MySqlParserCP932 = 757 + MySqlParserDEC8 = 758 + MySqlParserEUCJPMS = 759 + MySqlParserEUCKR = 760 + MySqlParserGB18030 = 761 + MySqlParserGB2312 = 762 + MySqlParserGBK = 763 + MySqlParserGEOSTD8 = 764 + MySqlParserGREEK = 765 + MySqlParserHEBREW = 766 + MySqlParserHP8 = 767 + MySqlParserKEYBCS2 = 768 + MySqlParserKOI8R = 769 + MySqlParserKOI8U = 770 + MySqlParserLATIN1 = 771 + MySqlParserLATIN2 = 772 + MySqlParserLATIN5 = 773 + MySqlParserLATIN7 = 774 + MySqlParserMACCE = 775 + MySqlParserMACROMAN = 776 + MySqlParserSJIS = 777 + MySqlParserSWE7 = 778 + MySqlParserTIS620 = 779 + MySqlParserUCS2 = 780 + MySqlParserUJIS = 781 + MySqlParserUTF16 = 782 + MySqlParserUTF16LE = 783 + MySqlParserUTF32 = 784 + MySqlParserUTF8 = 785 + MySqlParserUTF8MB3 = 786 + MySqlParserUTF8MB4 = 787 + MySqlParserARCHIVE = 788 + MySqlParserBLACKHOLE = 789 + MySqlParserCSV = 790 + MySqlParserFEDERATED = 791 + MySqlParserINNODB = 792 + MySqlParserMEMORY = 793 + MySqlParserMRG_MYISAM = 794 + MySqlParserMYISAM = 795 + MySqlParserNDB = 796 + MySqlParserNDBCLUSTER = 797 + MySqlParserPERFORMANCE_SCHEMA = 798 + MySqlParserTOKUDB = 799 + MySqlParserREPEATABLE = 800 + MySqlParserCOMMITTED = 801 + MySqlParserUNCOMMITTED = 802 + MySqlParserSERIALIZABLE = 803 + MySqlParserGEOMETRYCOLLECTION = 804 + MySqlParserGEOMCOLLECTION = 805 + MySqlParserGEOMETRY = 806 + MySqlParserLINESTRING = 807 + MySqlParserMULTILINESTRING = 808 + MySqlParserMULTIPOINT = 809 + MySqlParserMULTIPOLYGON = 810 + MySqlParserPOINT = 811 + MySqlParserPOLYGON = 812 + MySqlParserABS = 813 + MySqlParserACOS = 814 + MySqlParserADDDATE = 815 + MySqlParserADDTIME = 816 + MySqlParserAES_DECRYPT = 817 + MySqlParserAES_ENCRYPT = 818 + MySqlParserAREA = 819 + MySqlParserASBINARY = 820 + MySqlParserASIN = 821 + MySqlParserASTEXT = 822 + MySqlParserASWKB = 823 + MySqlParserASWKT = 824 + MySqlParserASYMMETRIC_DECRYPT = 825 + MySqlParserASYMMETRIC_DERIVE = 826 + MySqlParserASYMMETRIC_ENCRYPT = 827 + MySqlParserASYMMETRIC_SIGN = 828 + MySqlParserASYMMETRIC_VERIFY = 829 + MySqlParserATAN = 830 + MySqlParserATAN2 = 831 + MySqlParserBENCHMARK = 832 + MySqlParserBIN = 833 + MySqlParserBIT_COUNT = 834 + MySqlParserBIT_LENGTH = 835 + MySqlParserBUFFER = 836 + MySqlParserCATALOG_NAME = 837 + MySqlParserCEIL = 838 + MySqlParserCEILING = 839 + MySqlParserCENTROID = 840 + MySqlParserCHARACTER_LENGTH = 841 + MySqlParserCHARSET = 842 + MySqlParserCHAR_LENGTH = 843 + MySqlParserCOERCIBILITY = 844 + MySqlParserCOLLATION = 845 + MySqlParserCOMPRESS = 846 + MySqlParserCONCAT = 847 + MySqlParserCONCAT_WS = 848 + MySqlParserCONNECTION_ID = 849 + MySqlParserCONV = 850 + MySqlParserCONVERT_TZ = 851 + MySqlParserCOS = 852 + MySqlParserCOT = 853 + MySqlParserCRC32 = 854 + MySqlParserCREATE_ASYMMETRIC_PRIV_KEY = 855 + MySqlParserCREATE_ASYMMETRIC_PUB_KEY = 856 + MySqlParserCREATE_DH_PARAMETERS = 857 + MySqlParserCREATE_DIGEST = 858 + MySqlParserCROSSES = 859 + MySqlParserDATEDIFF = 860 + MySqlParserDATE_FORMAT = 861 + MySqlParserDAYNAME = 862 + MySqlParserDAYOFMONTH = 863 + MySqlParserDAYOFWEEK = 864 + MySqlParserDAYOFYEAR = 865 + MySqlParserDECODE = 866 + MySqlParserDEGREES = 867 + MySqlParserDES_DECRYPT = 868 + MySqlParserDES_ENCRYPT = 869 + MySqlParserDIMENSION = 870 + MySqlParserDISJOINT = 871 + MySqlParserDISTANCE = 872 + MySqlParserELT = 873 + MySqlParserENCODE = 874 + MySqlParserENCRYPT = 875 + MySqlParserENDPOINT = 876 + MySqlParserENGINE_ATTRIBUTE = 877 + MySqlParserENVELOPE = 878 + MySqlParserEQUALS = 879 + MySqlParserEXP = 880 + MySqlParserEXPORT_SET = 881 + MySqlParserEXTERIORRING = 882 + MySqlParserEXTRACTVALUE = 883 + MySqlParserFIELD = 884 + MySqlParserFIND_IN_SET = 885 + MySqlParserFLOOR = 886 + MySqlParserFORMAT = 887 + MySqlParserFOUND_ROWS = 888 + MySqlParserFROM_BASE64 = 889 + MySqlParserFROM_DAYS = 890 + MySqlParserFROM_UNIXTIME = 891 + MySqlParserGEOMCOLLFROMTEXT = 892 + MySqlParserGEOMCOLLFROMWKB = 893 + MySqlParserGEOMETRYCOLLECTIONFROMTEXT = 894 + MySqlParserGEOMETRYCOLLECTIONFROMWKB = 895 + MySqlParserGEOMETRYFROMTEXT = 896 + MySqlParserGEOMETRYFROMWKB = 897 + MySqlParserGEOMETRYN = 898 + MySqlParserGEOMETRYTYPE = 899 + MySqlParserGEOMFROMTEXT = 900 + MySqlParserGEOMFROMWKB = 901 + MySqlParserGET_FORMAT = 902 + MySqlParserGET_LOCK = 903 + MySqlParserGLENGTH = 904 + MySqlParserGREATEST = 905 + MySqlParserGTID_SUBSET = 906 + MySqlParserGTID_SUBTRACT = 907 + MySqlParserHEX = 908 + MySqlParserIFNULL = 909 + MySqlParserINET6_ATON = 910 + MySqlParserINET6_NTOA = 911 + MySqlParserINET_ATON = 912 + MySqlParserINET_NTOA = 913 + MySqlParserINSTR = 914 + MySqlParserINTERIORRINGN = 915 + MySqlParserINTERSECTS = 916 + MySqlParserISCLOSED = 917 + MySqlParserISEMPTY = 918 + MySqlParserISNULL = 919 + MySqlParserISSIMPLE = 920 + MySqlParserIS_FREE_LOCK = 921 + MySqlParserIS_IPV4 = 922 + MySqlParserIS_IPV4_COMPAT = 923 + MySqlParserIS_IPV4_MAPPED = 924 + MySqlParserIS_IPV6 = 925 + MySqlParserIS_USED_LOCK = 926 + MySqlParserLAST_INSERT_ID = 927 + MySqlParserLCASE = 928 + MySqlParserLEAST = 929 + MySqlParserLENGTH = 930 + MySqlParserLINEFROMTEXT = 931 + MySqlParserLINEFROMWKB = 932 + MySqlParserLINESTRINGFROMTEXT = 933 + MySqlParserLINESTRINGFROMWKB = 934 + MySqlParserLN = 935 + MySqlParserLOAD_FILE = 936 + MySqlParserLOCATE = 937 + MySqlParserLOG = 938 + MySqlParserLOG10 = 939 + MySqlParserLOG2 = 940 + MySqlParserLOWER = 941 + MySqlParserLPAD = 942 + MySqlParserLTRIM = 943 + MySqlParserMAKEDATE = 944 + MySqlParserMAKETIME = 945 + MySqlParserMAKE_SET = 946 + MySqlParserMASTER_POS_WAIT = 947 + MySqlParserMBRCONTAINS = 948 + MySqlParserMBRDISJOINT = 949 + MySqlParserMBREQUAL = 950 + MySqlParserMBRINTERSECTS = 951 + MySqlParserMBROVERLAPS = 952 + MySqlParserMBRTOUCHES = 953 + MySqlParserMBRWITHIN = 954 + MySqlParserMD5 = 955 + MySqlParserMLINEFROMTEXT = 956 + MySqlParserMLINEFROMWKB = 957 + MySqlParserMONTHNAME = 958 + MySqlParserMPOINTFROMTEXT = 959 + MySqlParserMPOINTFROMWKB = 960 + MySqlParserMPOLYFROMTEXT = 961 + MySqlParserMPOLYFROMWKB = 962 + MySqlParserMULTILINESTRINGFROMTEXT = 963 + MySqlParserMULTILINESTRINGFROMWKB = 964 + MySqlParserMULTIPOINTFROMTEXT = 965 + MySqlParserMULTIPOINTFROMWKB = 966 + MySqlParserMULTIPOLYGONFROMTEXT = 967 + MySqlParserMULTIPOLYGONFROMWKB = 968 + MySqlParserNAME_CONST = 969 + MySqlParserNULLIF = 970 + MySqlParserNUMGEOMETRIES = 971 + MySqlParserNUMINTERIORRINGS = 972 + MySqlParserNUMPOINTS = 973 + MySqlParserOCT = 974 + MySqlParserOCTET_LENGTH = 975 + MySqlParserORD = 976 + MySqlParserOVERLAPS = 977 + MySqlParserPERIOD_ADD = 978 + MySqlParserPERIOD_DIFF = 979 + MySqlParserPI = 980 + MySqlParserPOINTFROMTEXT = 981 + MySqlParserPOINTFROMWKB = 982 + MySqlParserPOINTN = 983 + MySqlParserPOLYFROMTEXT = 984 + MySqlParserPOLYFROMWKB = 985 + MySqlParserPOLYGONFROMTEXT = 986 + MySqlParserPOLYGONFROMWKB = 987 + MySqlParserPOW = 988 + MySqlParserPOWER = 989 + MySqlParserQUOTE = 990 + MySqlParserRADIANS = 991 + MySqlParserRAND = 992 + MySqlParserRANDOM = 993 + MySqlParserRANDOM_BYTES = 994 + MySqlParserRELEASE_LOCK = 995 + MySqlParserREVERSE = 996 + MySqlParserROUND = 997 + MySqlParserROW_COUNT = 998 + MySqlParserRPAD = 999 + MySqlParserRTRIM = 1000 + MySqlParserSEC_TO_TIME = 1001 + MySqlParserSECONDARY_ENGINE_ATTRIBUTE = 1002 + MySqlParserSESSION_USER = 1003 + MySqlParserSHA = 1004 + MySqlParserSHA1 = 1005 + MySqlParserSHA2 = 1006 + MySqlParserSCHEMA_NAME = 1007 + MySqlParserSIGN = 1008 + MySqlParserSIN = 1009 + MySqlParserSLEEP = 1010 + MySqlParserSOUNDEX = 1011 + MySqlParserSQL_THREAD_WAIT_AFTER_GTIDS = 1012 + MySqlParserSQRT = 1013 + MySqlParserSRID = 1014 + MySqlParserSTARTPOINT = 1015 + MySqlParserSTRCMP = 1016 + MySqlParserSTR_TO_DATE = 1017 + MySqlParserST_AREA = 1018 + MySqlParserST_ASBINARY = 1019 + MySqlParserST_ASTEXT = 1020 + MySqlParserST_ASWKB = 1021 + MySqlParserST_ASWKT = 1022 + MySqlParserST_BUFFER = 1023 + MySqlParserST_CENTROID = 1024 + MySqlParserST_CONTAINS = 1025 + MySqlParserST_CROSSES = 1026 + MySqlParserST_DIFFERENCE = 1027 + MySqlParserST_DIMENSION = 1028 + MySqlParserST_DISJOINT = 1029 + MySqlParserST_DISTANCE = 1030 + MySqlParserST_ENDPOINT = 1031 + MySqlParserST_ENVELOPE = 1032 + MySqlParserST_EQUALS = 1033 + MySqlParserST_EXTERIORRING = 1034 + MySqlParserST_GEOMCOLLFROMTEXT = 1035 + MySqlParserST_GEOMCOLLFROMTXT = 1036 + MySqlParserST_GEOMCOLLFROMWKB = 1037 + MySqlParserST_GEOMETRYCOLLECTIONFROMTEXT = 1038 + MySqlParserST_GEOMETRYCOLLECTIONFROMWKB = 1039 + MySqlParserST_GEOMETRYFROMTEXT = 1040 + MySqlParserST_GEOMETRYFROMWKB = 1041 + MySqlParserST_GEOMETRYN = 1042 + MySqlParserST_GEOMETRYTYPE = 1043 + MySqlParserST_GEOMFROMTEXT = 1044 + MySqlParserST_GEOMFROMWKB = 1045 + MySqlParserST_INTERIORRINGN = 1046 + MySqlParserST_INTERSECTION = 1047 + MySqlParserST_INTERSECTS = 1048 + MySqlParserST_ISCLOSED = 1049 + MySqlParserST_ISEMPTY = 1050 + MySqlParserST_ISSIMPLE = 1051 + MySqlParserST_LINEFROMTEXT = 1052 + MySqlParserST_LINEFROMWKB = 1053 + MySqlParserST_LINESTRINGFROMTEXT = 1054 + MySqlParserST_LINESTRINGFROMWKB = 1055 + MySqlParserST_NUMGEOMETRIES = 1056 + MySqlParserST_NUMINTERIORRING = 1057 + MySqlParserST_NUMINTERIORRINGS = 1058 + MySqlParserST_NUMPOINTS = 1059 + MySqlParserST_OVERLAPS = 1060 + MySqlParserST_POINTFROMTEXT = 1061 + MySqlParserST_POINTFROMWKB = 1062 + MySqlParserST_POINTN = 1063 + MySqlParserST_POLYFROMTEXT = 1064 + MySqlParserST_POLYFROMWKB = 1065 + MySqlParserST_POLYGONFROMTEXT = 1066 + MySqlParserST_POLYGONFROMWKB = 1067 + MySqlParserST_SRID = 1068 + MySqlParserST_STARTPOINT = 1069 + MySqlParserST_SYMDIFFERENCE = 1070 + MySqlParserST_TOUCHES = 1071 + MySqlParserST_UNION = 1072 + MySqlParserST_WITHIN = 1073 + MySqlParserST_X = 1074 + MySqlParserST_Y = 1075 + MySqlParserSTRING_TO_VECTOR = 1076 + MySqlParserSUBDATE = 1077 + MySqlParserSUBSTRING_INDEX = 1078 + MySqlParserSUBTIME = 1079 + MySqlParserSYSTEM_USER = 1080 + MySqlParserTAN = 1081 + MySqlParserTIMEDIFF = 1082 + MySqlParserTIMESTAMPADD = 1083 + MySqlParserTIMESTAMPDIFF = 1084 + MySqlParserTIME_FORMAT = 1085 + MySqlParserTIME_TO_SEC = 1086 + MySqlParserTOUCHES = 1087 + MySqlParserTO_BASE64 = 1088 + MySqlParserTO_DAYS = 1089 + MySqlParserTO_SECONDS = 1090 + MySqlParserTP_CONNECTION_ADMIN = 1091 + MySqlParserUCASE = 1092 + MySqlParserUNCOMPRESS = 1093 + MySqlParserUNCOMPRESSED_LENGTH = 1094 + MySqlParserUNHEX = 1095 + MySqlParserUNIX_TIMESTAMP = 1096 + MySqlParserUPDATEXML = 1097 + MySqlParserUPPER = 1098 + MySqlParserUUID = 1099 + MySqlParserUUID_SHORT = 1100 + MySqlParserVALIDATE_PASSWORD_STRENGTH = 1101 + MySqlParserVECTOR_DIM = 1102 + MySqlParserVECTOR_TO_STRING = 1103 + MySqlParserVERSION = 1104 + MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS = 1105 + MySqlParserWEEKDAY = 1106 + MySqlParserWEEKOFYEAR = 1107 + MySqlParserWEIGHT_STRING = 1108 + MySqlParserWITHIN = 1109 + MySqlParserYEARWEEK = 1110 + MySqlParserY_FUNCTION = 1111 + MySqlParserX_FUNCTION = 1112 + MySqlParserVAR_ASSIGN = 1113 + MySqlParserPLUS_ASSIGN = 1114 + MySqlParserMINUS_ASSIGN = 1115 + MySqlParserMULT_ASSIGN = 1116 + MySqlParserDIV_ASSIGN = 1117 + MySqlParserMOD_ASSIGN = 1118 + MySqlParserAND_ASSIGN = 1119 + MySqlParserXOR_ASSIGN = 1120 + MySqlParserOR_ASSIGN = 1121 + MySqlParserSTAR = 1122 + MySqlParserDIVIDE = 1123 + MySqlParserMODULE = 1124 + MySqlParserPLUS = 1125 + MySqlParserMINUS = 1126 + MySqlParserDIV = 1127 + MySqlParserMOD = 1128 + MySqlParserEQUAL_SYMBOL = 1129 + MySqlParserGREATER_SYMBOL = 1130 + MySqlParserLESS_SYMBOL = 1131 + MySqlParserEXCLAMATION_SYMBOL = 1132 + MySqlParserBIT_NOT_OP = 1133 + MySqlParserBIT_OR_OP = 1134 + MySqlParserBIT_AND_OP = 1135 + MySqlParserBIT_XOR_OP = 1136 + MySqlParserDOT = 1137 + MySqlParserLR_BRACKET = 1138 + MySqlParserRR_BRACKET = 1139 + MySqlParserCOMMA = 1140 + MySqlParserSEMI = 1141 + MySqlParserAT_SIGN = 1142 + MySqlParserZERO_DECIMAL = 1143 + MySqlParserONE_DECIMAL = 1144 + MySqlParserTWO_DECIMAL = 1145 + MySqlParserSINGLE_QUOTE_SYMB = 1146 + MySqlParserDOUBLE_QUOTE_SYMB = 1147 + MySqlParserREVERSE_QUOTE_SYMB = 1148 + MySqlParserCOLON_SYMB = 1149 + MySqlParserCHARSET_REVERSE_QOUTE_STRING = 1150 + MySqlParserFILESIZE_LITERAL = 1151 + MySqlParserSTART_NATIONAL_STRING_LITERAL = 1152 + MySqlParserSTRING_LITERAL = 1153 + MySqlParserDECIMAL_LITERAL = 1154 + MySqlParserHEXADECIMAL_LITERAL = 1155 + MySqlParserREAL_LITERAL = 1156 + MySqlParserNULL_SPEC_LITERAL = 1157 + MySqlParserBIT_STRING = 1158 + MySqlParserSTRING_CHARSET_NAME = 1159 + MySqlParserDOT_ID = 1160 + MySqlParserID = 1161 + MySqlParserREVERSE_QUOTE_ID = 1162 + MySqlParserHOST_IP_ADDRESS = 1163 + MySqlParserLOCAL_ID = 1164 + MySqlParserGLOBAL_ID = 1165 + MySqlParserERROR_RECONGNIGION = 1166 +) + +// MySqlParser rules. +const ( + MySqlParserRULE_root = 0 + MySqlParserRULE_sqlStatements = 1 + MySqlParserRULE_sqlStatement = 2 + MySqlParserRULE_emptyStatement_ = 3 + MySqlParserRULE_ddlStatement = 4 + MySqlParserRULE_dmlStatement = 5 + MySqlParserRULE_transactionStatement = 6 + MySqlParserRULE_replicationStatement = 7 + MySqlParserRULE_preparedStatement = 8 + MySqlParserRULE_compoundStatement = 9 + MySqlParserRULE_administrationStatement = 10 + MySqlParserRULE_utilityStatement = 11 + MySqlParserRULE_createDatabase = 12 + MySqlParserRULE_createEvent = 13 + MySqlParserRULE_createIndex = 14 + MySqlParserRULE_createLogfileGroup = 15 + MySqlParserRULE_createProcedure = 16 + MySqlParserRULE_createFunction = 17 + MySqlParserRULE_createRole = 18 + MySqlParserRULE_createServer = 19 + MySqlParserRULE_createTable = 20 + MySqlParserRULE_createTablespaceInnodb = 21 + MySqlParserRULE_createTablespaceNdb = 22 + MySqlParserRULE_createTrigger = 23 + MySqlParserRULE_withClause = 24 + MySqlParserRULE_commonTableExpressions = 25 + MySqlParserRULE_cteName = 26 + MySqlParserRULE_cteColumnName = 27 + MySqlParserRULE_createView = 28 + MySqlParserRULE_createDatabaseOption = 29 + MySqlParserRULE_charSet = 30 + MySqlParserRULE_currentUserExpression = 31 + MySqlParserRULE_ownerStatement = 32 + MySqlParserRULE_scheduleExpression = 33 + MySqlParserRULE_timestampValue = 34 + MySqlParserRULE_intervalExpr = 35 + MySqlParserRULE_intervalType = 36 + MySqlParserRULE_enableType = 37 + MySqlParserRULE_indexType = 38 + MySqlParserRULE_indexOption = 39 + MySqlParserRULE_procedureParameter = 40 + MySqlParserRULE_functionParameter = 41 + MySqlParserRULE_routineOption = 42 + MySqlParserRULE_serverOption = 43 + MySqlParserRULE_createDefinitions = 44 + MySqlParserRULE_createDefinition = 45 + MySqlParserRULE_columnDefinition = 46 + MySqlParserRULE_columnConstraint = 47 + MySqlParserRULE_tableConstraint = 48 + MySqlParserRULE_referenceDefinition = 49 + MySqlParserRULE_referenceAction = 50 + MySqlParserRULE_referenceControlType = 51 + MySqlParserRULE_indexColumnDefinition = 52 + MySqlParserRULE_tableOption = 53 + MySqlParserRULE_tableType = 54 + MySqlParserRULE_tablespaceStorage = 55 + MySqlParserRULE_partitionDefinitions = 56 + MySqlParserRULE_partitionFunctionDefinition = 57 + MySqlParserRULE_subpartitionFunctionDefinition = 58 + MySqlParserRULE_partitionDefinition = 59 + MySqlParserRULE_partitionDefinerAtom = 60 + MySqlParserRULE_partitionDefinerVector = 61 + MySqlParserRULE_subpartitionDefinition = 62 + MySqlParserRULE_partitionOption = 63 + MySqlParserRULE_alterDatabase = 64 + MySqlParserRULE_alterEvent = 65 + MySqlParserRULE_alterFunction = 66 + MySqlParserRULE_alterInstance = 67 + MySqlParserRULE_alterLogfileGroup = 68 + MySqlParserRULE_alterProcedure = 69 + MySqlParserRULE_alterServer = 70 + MySqlParserRULE_alterTable = 71 + MySqlParserRULE_alterTablespace = 72 + MySqlParserRULE_alterView = 73 + MySqlParserRULE_alterSpecification = 74 + MySqlParserRULE_alterPartitionSpecification = 75 + MySqlParserRULE_dropDatabase = 76 + MySqlParserRULE_dropEvent = 77 + MySqlParserRULE_dropIndex = 78 + MySqlParserRULE_dropLogfileGroup = 79 + MySqlParserRULE_dropProcedure = 80 + MySqlParserRULE_dropFunction = 81 + MySqlParserRULE_dropServer = 82 + MySqlParserRULE_dropTable = 83 + MySqlParserRULE_dropTablespace = 84 + MySqlParserRULE_dropTrigger = 85 + MySqlParserRULE_dropView = 86 + MySqlParserRULE_dropRole = 87 + MySqlParserRULE_setRole = 88 + MySqlParserRULE_renameTable = 89 + MySqlParserRULE_renameTableClause = 90 + MySqlParserRULE_truncateTable = 91 + MySqlParserRULE_callStatement = 92 + MySqlParserRULE_deleteStatement = 93 + MySqlParserRULE_doStatement = 94 + MySqlParserRULE_handlerStatement = 95 + MySqlParserRULE_insertStatement = 96 + MySqlParserRULE_loadDataStatement = 97 + MySqlParserRULE_loadXmlStatement = 98 + MySqlParserRULE_replaceStatement = 99 + MySqlParserRULE_selectStatement = 100 + MySqlParserRULE_updateStatement = 101 + MySqlParserRULE_valuesStatement = 102 + MySqlParserRULE_insertStatementValue = 103 + MySqlParserRULE_updatedElement = 104 + MySqlParserRULE_assignmentField = 105 + MySqlParserRULE_lockClause = 106 + MySqlParserRULE_singleDeleteStatement = 107 + MySqlParserRULE_multipleDeleteStatement = 108 + MySqlParserRULE_handlerOpenStatement = 109 + MySqlParserRULE_handlerReadIndexStatement = 110 + MySqlParserRULE_handlerReadStatement = 111 + MySqlParserRULE_handlerCloseStatement = 112 + MySqlParserRULE_singleUpdateStatement = 113 + MySqlParserRULE_multipleUpdateStatement = 114 + MySqlParserRULE_orderByClause = 115 + MySqlParserRULE_orderByExpression = 116 + MySqlParserRULE_tableSources = 117 + MySqlParserRULE_tableSource = 118 + MySqlParserRULE_tableSourceItem = 119 + MySqlParserRULE_indexHint = 120 + MySqlParserRULE_indexHintType = 121 + MySqlParserRULE_joinPart = 122 + MySqlParserRULE_joinSpec = 123 + MySqlParserRULE_queryExpression = 124 + MySqlParserRULE_queryExpressionNointo = 125 + MySqlParserRULE_querySpecification = 126 + MySqlParserRULE_querySpecificationNointo = 127 + MySqlParserRULE_unionParenthesis = 128 + MySqlParserRULE_unionStatement = 129 + MySqlParserRULE_lateralStatement = 130 + MySqlParserRULE_jsonTable = 131 + MySqlParserRULE_jsonColumnList = 132 + MySqlParserRULE_jsonColumn = 133 + MySqlParserRULE_jsonOnEmpty = 134 + MySqlParserRULE_jsonOnError = 135 + MySqlParserRULE_selectSpec = 136 + MySqlParserRULE_selectElements = 137 + MySqlParserRULE_selectElement = 138 + MySqlParserRULE_selectIntoExpression = 139 + MySqlParserRULE_selectFieldsInto = 140 + MySqlParserRULE_selectLinesInto = 141 + MySqlParserRULE_fromClause = 142 + MySqlParserRULE_groupByClause = 143 + MySqlParserRULE_havingClause = 144 + MySqlParserRULE_windowClause = 145 + MySqlParserRULE_groupByItem = 146 + MySqlParserRULE_limitClause = 147 + MySqlParserRULE_limitClauseAtom = 148 + MySqlParserRULE_startTransaction = 149 + MySqlParserRULE_beginWork = 150 + MySqlParserRULE_commitWork = 151 + MySqlParserRULE_rollbackWork = 152 + MySqlParserRULE_savepointStatement = 153 + MySqlParserRULE_rollbackStatement = 154 + MySqlParserRULE_releaseStatement = 155 + MySqlParserRULE_lockTables = 156 + MySqlParserRULE_unlockTables = 157 + MySqlParserRULE_setAutocommitStatement = 158 + MySqlParserRULE_setTransactionStatement = 159 + MySqlParserRULE_transactionMode = 160 + MySqlParserRULE_lockTableElement = 161 + MySqlParserRULE_lockAction = 162 + MySqlParserRULE_transactionOption = 163 + MySqlParserRULE_transactionLevel = 164 + MySqlParserRULE_changeMaster = 165 + MySqlParserRULE_changeReplicationFilter = 166 + MySqlParserRULE_purgeBinaryLogs = 167 + MySqlParserRULE_resetMaster = 168 + MySqlParserRULE_resetSlave = 169 + MySqlParserRULE_startSlave = 170 + MySqlParserRULE_stopSlave = 171 + MySqlParserRULE_startGroupReplication = 172 + MySqlParserRULE_stopGroupReplication = 173 + MySqlParserRULE_masterOption = 174 + MySqlParserRULE_stringMasterOption = 175 + MySqlParserRULE_decimalMasterOption = 176 + MySqlParserRULE_boolMasterOption = 177 + MySqlParserRULE_channelOption = 178 + MySqlParserRULE_replicationFilter = 179 + MySqlParserRULE_tablePair = 180 + MySqlParserRULE_threadType = 181 + MySqlParserRULE_untilOption = 182 + MySqlParserRULE_connectionOption = 183 + MySqlParserRULE_gtuidSet = 184 + MySqlParserRULE_xaStartTransaction = 185 + MySqlParserRULE_xaEndTransaction = 186 + MySqlParserRULE_xaPrepareStatement = 187 + MySqlParserRULE_xaCommitWork = 188 + MySqlParserRULE_xaRollbackWork = 189 + MySqlParserRULE_xaRecoverWork = 190 + MySqlParserRULE_prepareStatement = 191 + MySqlParserRULE_executeStatement = 192 + MySqlParserRULE_deallocatePrepare = 193 + MySqlParserRULE_routineBody = 194 + MySqlParserRULE_blockStatement = 195 + MySqlParserRULE_caseStatement = 196 + MySqlParserRULE_ifStatement = 197 + MySqlParserRULE_iterateStatement = 198 + MySqlParserRULE_leaveStatement = 199 + MySqlParserRULE_loopStatement = 200 + MySqlParserRULE_repeatStatement = 201 + MySqlParserRULE_returnStatement = 202 + MySqlParserRULE_whileStatement = 203 + MySqlParserRULE_cursorStatement = 204 + MySqlParserRULE_declareVariable = 205 + MySqlParserRULE_declareCondition = 206 + MySqlParserRULE_declareCursor = 207 + MySqlParserRULE_declareHandler = 208 + MySqlParserRULE_handlerConditionValue = 209 + MySqlParserRULE_procedureSqlStatement = 210 + MySqlParserRULE_caseAlternative = 211 + MySqlParserRULE_elifAlternative = 212 + MySqlParserRULE_alterUser = 213 + MySqlParserRULE_createUser = 214 + MySqlParserRULE_dropUser = 215 + MySqlParserRULE_grantStatement = 216 + MySqlParserRULE_roleOption = 217 + MySqlParserRULE_grantProxy = 218 + MySqlParserRULE_renameUser = 219 + MySqlParserRULE_revokeStatement = 220 + MySqlParserRULE_revokeProxy = 221 + MySqlParserRULE_setPasswordStatement = 222 + MySqlParserRULE_userSpecification = 223 + MySqlParserRULE_userAuthOption = 224 + MySqlParserRULE_authOptionClause = 225 + MySqlParserRULE_authenticationRule = 226 + MySqlParserRULE_tlsOption = 227 + MySqlParserRULE_userResourceOption = 228 + MySqlParserRULE_userPasswordOption = 229 + MySqlParserRULE_userLockOption = 230 + MySqlParserRULE_privelegeClause = 231 + MySqlParserRULE_privilege = 232 + MySqlParserRULE_privilegeLevel = 233 + MySqlParserRULE_renameUserClause = 234 + MySqlParserRULE_analyzeTable = 235 + MySqlParserRULE_checkTable = 236 + MySqlParserRULE_checksumTable = 237 + MySqlParserRULE_optimizeTable = 238 + MySqlParserRULE_repairTable = 239 + MySqlParserRULE_checkTableOption = 240 + MySqlParserRULE_createUdfunction = 241 + MySqlParserRULE_installPlugin = 242 + MySqlParserRULE_uninstallPlugin = 243 + MySqlParserRULE_setStatement = 244 + MySqlParserRULE_showStatement = 245 + MySqlParserRULE_variableClause = 246 + MySqlParserRULE_showCommonEntity = 247 + MySqlParserRULE_showFilter = 248 + MySqlParserRULE_showGlobalInfoClause = 249 + MySqlParserRULE_showSchemaEntity = 250 + MySqlParserRULE_showProfileType = 251 + MySqlParserRULE_binlogStatement = 252 + MySqlParserRULE_cacheIndexStatement = 253 + MySqlParserRULE_flushStatement = 254 + MySqlParserRULE_killStatement = 255 + MySqlParserRULE_loadIndexIntoCache = 256 + MySqlParserRULE_resetStatement = 257 + MySqlParserRULE_shutdownStatement = 258 + MySqlParserRULE_tableIndexes = 259 + MySqlParserRULE_flushOption = 260 + MySqlParserRULE_flushTableOption = 261 + MySqlParserRULE_loadedTableIndexes = 262 + MySqlParserRULE_simpleDescribeStatement = 263 + MySqlParserRULE_fullDescribeStatement = 264 + MySqlParserRULE_helpStatement = 265 + MySqlParserRULE_useStatement = 266 + MySqlParserRULE_signalStatement = 267 + MySqlParserRULE_resignalStatement = 268 + MySqlParserRULE_signalConditionInformation = 269 + MySqlParserRULE_withStatement = 270 + MySqlParserRULE_tableStatement = 271 + MySqlParserRULE_diagnosticsStatement = 272 + MySqlParserRULE_diagnosticsConditionInformationName = 273 + MySqlParserRULE_describeObjectClause = 274 + MySqlParserRULE_fullId = 275 + MySqlParserRULE_tableName = 276 + MySqlParserRULE_roleName = 277 + MySqlParserRULE_fullColumnName = 278 + MySqlParserRULE_indexColumnName = 279 + MySqlParserRULE_simpleUserName = 280 + MySqlParserRULE_hostName = 281 + MySqlParserRULE_userName = 282 + MySqlParserRULE_mysqlVariable = 283 + MySqlParserRULE_charsetName = 284 + MySqlParserRULE_collationName = 285 + MySqlParserRULE_engineName = 286 + MySqlParserRULE_engineNameBase = 287 + MySqlParserRULE_uuidSet = 288 + MySqlParserRULE_xid = 289 + MySqlParserRULE_xuidStringId = 290 + MySqlParserRULE_authPlugin = 291 + MySqlParserRULE_uid = 292 + MySqlParserRULE_simpleId = 293 + MySqlParserRULE_dottedId = 294 + MySqlParserRULE_decimalLiteral = 295 + MySqlParserRULE_fileSizeLiteral = 296 + MySqlParserRULE_stringLiteral = 297 + MySqlParserRULE_booleanLiteral = 298 + MySqlParserRULE_hexadecimalLiteral = 299 + MySqlParserRULE_nullNotnull = 300 + MySqlParserRULE_constant = 301 + MySqlParserRULE_dataType = 302 + MySqlParserRULE_collectionOptions = 303 + MySqlParserRULE_convertedDataType = 304 + MySqlParserRULE_lengthOneDimension = 305 + MySqlParserRULE_lengthTwoDimension = 306 + MySqlParserRULE_lengthTwoOptionalDimension = 307 + MySqlParserRULE_uidList = 308 + MySqlParserRULE_fullColumnNameList = 309 + MySqlParserRULE_tables = 310 + MySqlParserRULE_indexColumnNames = 311 + MySqlParserRULE_expressions = 312 + MySqlParserRULE_expressionsWithDefaults = 313 + MySqlParserRULE_constants = 314 + MySqlParserRULE_simpleStrings = 315 + MySqlParserRULE_userVariables = 316 + MySqlParserRULE_defaultValue = 317 + MySqlParserRULE_currentTimestamp = 318 + MySqlParserRULE_expressionOrDefault = 319 + MySqlParserRULE_ifExists = 320 + MySqlParserRULE_ifNotExists = 321 + MySqlParserRULE_orReplace = 322 + MySqlParserRULE_waitNowaitClause = 323 + MySqlParserRULE_functionCall = 324 + MySqlParserRULE_specificFunction = 325 + MySqlParserRULE_caseFuncAlternative = 326 + MySqlParserRULE_levelsInWeightString = 327 + MySqlParserRULE_levelInWeightListElement = 328 + MySqlParserRULE_aggregateWindowedFunction = 329 + MySqlParserRULE_nonAggregateWindowedFunction = 330 + MySqlParserRULE_overClause = 331 + MySqlParserRULE_windowSpec = 332 + MySqlParserRULE_windowName = 333 + MySqlParserRULE_frameClause = 334 + MySqlParserRULE_frameUnits = 335 + MySqlParserRULE_frameExtent = 336 + MySqlParserRULE_frameBetween = 337 + MySqlParserRULE_frameRange = 338 + MySqlParserRULE_partitionClause = 339 + MySqlParserRULE_scalarFunctionName = 340 + MySqlParserRULE_passwordFunctionClause = 341 + MySqlParserRULE_functionArgs = 342 + MySqlParserRULE_functionArg = 343 + MySqlParserRULE_expression = 344 + MySqlParserRULE_predicate = 345 + MySqlParserRULE_expressionAtom = 346 + MySqlParserRULE_unaryOperator = 347 + MySqlParserRULE_comparisonOperator = 348 + MySqlParserRULE_logicalOperator = 349 + MySqlParserRULE_bitOperator = 350 + MySqlParserRULE_multOperator = 351 + MySqlParserRULE_addOperator = 352 + MySqlParserRULE_jsonOperator = 353 + MySqlParserRULE_charsetNameBase = 354 + MySqlParserRULE_transactionLevelBase = 355 + MySqlParserRULE_privilegesBase = 356 + MySqlParserRULE_intervalTypeBase = 357 + MySqlParserRULE_dataTypeBase = 358 + MySqlParserRULE_keywordsCanBeId = 359 + MySqlParserRULE_functionNameBase = 360 +) + +// IRootContext is an interface to support dynamic dispatch. +type IRootContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EOF() antlr.TerminalNode + SqlStatements() ISqlStatementsContext + AllMINUS() []antlr.TerminalNode + MINUS(i int) antlr.TerminalNode + + // IsRootContext differentiates from other interfaces. + IsRootContext() +} + +type RootContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRootContext() *RootContext { + var p = new(RootContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_root + return p +} + +func InitEmptyRootContext(p *RootContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_root +} + +func (*RootContext) IsRootContext() {} + +func NewRootContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RootContext { + var p = new(RootContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_root + + return p +} + +func (s *RootContext) GetParser() antlr.Parser { return s.parser } + +func (s *RootContext) EOF() antlr.TerminalNode { + return s.GetToken(MySqlParserEOF, 0) +} + +func (s *RootContext) SqlStatements() ISqlStatementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISqlStatementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISqlStatementsContext) +} + +func (s *RootContext) AllMINUS() []antlr.TerminalNode { + return s.GetTokens(MySqlParserMINUS) +} + +func (s *RootContext) MINUS(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserMINUS, i) +} + +func (s *RootContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RootContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RootContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterRoot(s) + } +} + +func (s *RootContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitRoot(s) + } +} + +func (p *MySqlParser) Root() (localctx IRootContext) { + localctx = NewRootContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 0, MySqlParserRULE_root) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(723) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&4614060972218253952) != 0) || ((int64((_la-71)) & ^0x3f) == 0 && ((int64(1)<<(_la-71))&2306124490637066243) != 0) || ((int64((_la-138)) & ^0x3f) == 0 && ((int64(1)<<(_la-138))&19509751503569451) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&36099165796700291) != 0) || ((int64((_la-433)) & ^0x3f) == 0 && ((int64(1)<<(_la-433))&16782337) != 0) || ((int64((_la-561)) & ^0x3f) == 0 && ((int64(1)<<(_la-561))&17730162917377) != 0) || ((int64((_la-630)) & ^0x3f) == 0 && ((int64(1)<<(_la-630))&4503604056555585) != 0) || _la == MySqlParserEXECUTE || _la == MySqlParserSHUTDOWN || _la == MySqlParserLR_BRACKET || _la == MySqlParserSEMI { + { + p.SetState(722) + p.SqlStatements() + } + + } + p.SetState(727) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserMINUS { + { + p.SetState(725) + p.Match(MySqlParserMINUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(726) + p.Match(MySqlParserMINUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(729) + p.Match(MySqlParserEOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISqlStatementsContext is an interface to support dynamic dispatch. +type ISqlStatementsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllSqlStatement() []ISqlStatementContext + SqlStatement(i int) ISqlStatementContext + AllEmptyStatement_() []IEmptyStatement_Context + EmptyStatement_(i int) IEmptyStatement_Context + AllSEMI() []antlr.TerminalNode + SEMI(i int) antlr.TerminalNode + AllMINUS() []antlr.TerminalNode + MINUS(i int) antlr.TerminalNode + + // IsSqlStatementsContext differentiates from other interfaces. + IsSqlStatementsContext() +} + +type SqlStatementsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySqlStatementsContext() *SqlStatementsContext { + var p = new(SqlStatementsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_sqlStatements + return p +} + +func InitEmptySqlStatementsContext(p *SqlStatementsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_sqlStatements +} + +func (*SqlStatementsContext) IsSqlStatementsContext() {} + +func NewSqlStatementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SqlStatementsContext { + var p = new(SqlStatementsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_sqlStatements + + return p +} + +func (s *SqlStatementsContext) GetParser() antlr.Parser { return s.parser } + +func (s *SqlStatementsContext) AllSqlStatement() []ISqlStatementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISqlStatementContext); ok { + len++ + } + } + + tst := make([]ISqlStatementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISqlStatementContext); ok { + tst[i] = t.(ISqlStatementContext) + i++ + } + } + + return tst +} + +func (s *SqlStatementsContext) SqlStatement(i int) ISqlStatementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISqlStatementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISqlStatementContext) +} + +func (s *SqlStatementsContext) AllEmptyStatement_() []IEmptyStatement_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IEmptyStatement_Context); ok { + len++ + } + } + + tst := make([]IEmptyStatement_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IEmptyStatement_Context); ok { + tst[i] = t.(IEmptyStatement_Context) + i++ + } + } + + return tst +} + +func (s *SqlStatementsContext) EmptyStatement_(i int) IEmptyStatement_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEmptyStatement_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IEmptyStatement_Context) +} + +func (s *SqlStatementsContext) AllSEMI() []antlr.TerminalNode { + return s.GetTokens(MySqlParserSEMI) +} + +func (s *SqlStatementsContext) SEMI(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserSEMI, i) +} + +func (s *SqlStatementsContext) AllMINUS() []antlr.TerminalNode { + return s.GetTokens(MySqlParserMINUS) +} + +func (s *SqlStatementsContext) MINUS(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserMINUS, i) +} + +func (s *SqlStatementsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SqlStatementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SqlStatementsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSqlStatements(s) + } +} + +func (s *SqlStatementsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSqlStatements(s) + } +} + +func (p *MySqlParser) SqlStatements() (localctx ISqlStatementsContext) { + localctx = NewSqlStatementsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2, MySqlParserRULE_sqlStatements) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(742) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 5, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(740) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserALTER, MySqlParserANALYZE, MySqlParserCALL, MySqlParserCHANGE, MySqlParserCHECK, MySqlParserCREATE, MySqlParserDELETE, MySqlParserDESC, MySqlParserDESCRIBE, MySqlParserDROP, MySqlParserEXPLAIN, MySqlParserGET, MySqlParserGRANT, MySqlParserINSERT, MySqlParserKILL, MySqlParserLOAD, MySqlParserLOCK, MySqlParserOPTIMIZE, MySqlParserPURGE, MySqlParserRELEASE, MySqlParserRENAME, MySqlParserREPLACE, MySqlParserRESIGNAL, MySqlParserREVOKE, MySqlParserSELECT, MySqlParserSET, MySqlParserSHOW, MySqlParserSIGNAL, MySqlParserTABLE, MySqlParserUNLOCK, MySqlParserUPDATE, MySqlParserUSE, MySqlParserVALUES, MySqlParserWITH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserCACHE, MySqlParserCHECKSUM, MySqlParserCOMMIT, MySqlParserDEALLOCATE, MySqlParserDO, MySqlParserFLUSH, MySqlParserHANDLER, MySqlParserHELP, MySqlParserINSTALL, MySqlParserPREPARE, MySqlParserREPAIR, MySqlParserRESET, MySqlParserROLLBACK, MySqlParserSAVEPOINT, MySqlParserSTART, MySqlParserSTOP, MySqlParserTRUNCATE, MySqlParserUNINSTALL, MySqlParserXA, MySqlParserEXECUTE, MySqlParserSHUTDOWN, MySqlParserLR_BRACKET: + { + p.SetState(731) + p.SqlStatement() + } + p.SetState(734) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserMINUS { + { + p.SetState(732) + p.Match(MySqlParserMINUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(733) + p.Match(MySqlParserMINUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(737) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 3, p.GetParserRuleContext()) == 1 { + { + p.SetState(736) + p.Match(MySqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case MySqlParserSEMI: + { + p.SetState(739) + p.EmptyStatement_() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(744) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 5, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(754) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserALTER, MySqlParserANALYZE, MySqlParserCALL, MySqlParserCHANGE, MySqlParserCHECK, MySqlParserCREATE, MySqlParserDELETE, MySqlParserDESC, MySqlParserDESCRIBE, MySqlParserDROP, MySqlParserEXPLAIN, MySqlParserGET, MySqlParserGRANT, MySqlParserINSERT, MySqlParserKILL, MySqlParserLOAD, MySqlParserLOCK, MySqlParserOPTIMIZE, MySqlParserPURGE, MySqlParserRELEASE, MySqlParserRENAME, MySqlParserREPLACE, MySqlParserRESIGNAL, MySqlParserREVOKE, MySqlParserSELECT, MySqlParserSET, MySqlParserSHOW, MySqlParserSIGNAL, MySqlParserTABLE, MySqlParserUNLOCK, MySqlParserUPDATE, MySqlParserUSE, MySqlParserVALUES, MySqlParserWITH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserCACHE, MySqlParserCHECKSUM, MySqlParserCOMMIT, MySqlParserDEALLOCATE, MySqlParserDO, MySqlParserFLUSH, MySqlParserHANDLER, MySqlParserHELP, MySqlParserINSTALL, MySqlParserPREPARE, MySqlParserREPAIR, MySqlParserRESET, MySqlParserROLLBACK, MySqlParserSAVEPOINT, MySqlParserSTART, MySqlParserSTOP, MySqlParserTRUNCATE, MySqlParserUNINSTALL, MySqlParserXA, MySqlParserEXECUTE, MySqlParserSHUTDOWN, MySqlParserLR_BRACKET: + { + p.SetState(745) + p.SqlStatement() + } + p.SetState(751) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 7, p.GetParserRuleContext()) == 1 { + p.SetState(748) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserMINUS { + { + p.SetState(746) + p.Match(MySqlParserMINUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(747) + p.Match(MySqlParserMINUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(750) + p.Match(MySqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case MySqlParserSEMI: + { + p.SetState(753) + p.EmptyStatement_() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISqlStatementContext is an interface to support dynamic dispatch. +type ISqlStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DdlStatement() IDdlStatementContext + DmlStatement() IDmlStatementContext + TransactionStatement() ITransactionStatementContext + ReplicationStatement() IReplicationStatementContext + PreparedStatement() IPreparedStatementContext + AdministrationStatement() IAdministrationStatementContext + UtilityStatement() IUtilityStatementContext + + // IsSqlStatementContext differentiates from other interfaces. + IsSqlStatementContext() +} + +type SqlStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySqlStatementContext() *SqlStatementContext { + var p = new(SqlStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_sqlStatement + return p +} + +func InitEmptySqlStatementContext(p *SqlStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_sqlStatement +} + +func (*SqlStatementContext) IsSqlStatementContext() {} + +func NewSqlStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SqlStatementContext { + var p = new(SqlStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_sqlStatement + + return p +} + +func (s *SqlStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *SqlStatementContext) DdlStatement() IDdlStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDdlStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDdlStatementContext) +} + +func (s *SqlStatementContext) DmlStatement() IDmlStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDmlStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDmlStatementContext) +} + +func (s *SqlStatementContext) TransactionStatement() ITransactionStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITransactionStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITransactionStatementContext) +} + +func (s *SqlStatementContext) ReplicationStatement() IReplicationStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReplicationStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReplicationStatementContext) +} + +func (s *SqlStatementContext) PreparedStatement() IPreparedStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPreparedStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPreparedStatementContext) +} + +func (s *SqlStatementContext) AdministrationStatement() IAdministrationStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAdministrationStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAdministrationStatementContext) +} + +func (s *SqlStatementContext) UtilityStatement() IUtilityStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUtilityStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUtilityStatementContext) +} + +func (s *SqlStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SqlStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SqlStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSqlStatement(s) + } +} + +func (s *SqlStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSqlStatement(s) + } +} + +func (p *MySqlParser) SqlStatement() (localctx ISqlStatementContext) { + localctx = NewSqlStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 4, MySqlParserRULE_sqlStatement) + p.SetState(763) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 9, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(756) + p.DdlStatement() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(757) + p.DmlStatement() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(758) + p.TransactionStatement() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(759) + p.ReplicationStatement() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(760) + p.PreparedStatement() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(761) + p.AdministrationStatement() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(762) + p.UtilityStatement() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IEmptyStatement_Context is an interface to support dynamic dispatch. +type IEmptyStatement_Context interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SEMI() antlr.TerminalNode + + // IsEmptyStatement_Context differentiates from other interfaces. + IsEmptyStatement_Context() +} + +type EmptyStatement_Context struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEmptyStatement_Context() *EmptyStatement_Context { + var p = new(EmptyStatement_Context) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_emptyStatement_ + return p +} + +func InitEmptyEmptyStatement_Context(p *EmptyStatement_Context) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_emptyStatement_ +} + +func (*EmptyStatement_Context) IsEmptyStatement_Context() {} + +func NewEmptyStatement_Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EmptyStatement_Context { + var p = new(EmptyStatement_Context) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_emptyStatement_ + + return p +} + +func (s *EmptyStatement_Context) GetParser() antlr.Parser { return s.parser } + +func (s *EmptyStatement_Context) SEMI() antlr.TerminalNode { + return s.GetToken(MySqlParserSEMI, 0) +} + +func (s *EmptyStatement_Context) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *EmptyStatement_Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *EmptyStatement_Context) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterEmptyStatement_(s) + } +} + +func (s *EmptyStatement_Context) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitEmptyStatement_(s) + } +} + +func (p *MySqlParser) EmptyStatement_() (localctx IEmptyStatement_Context) { + localctx = NewEmptyStatement_Context(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 6, MySqlParserRULE_emptyStatement_) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(765) + p.Match(MySqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDdlStatementContext is an interface to support dynamic dispatch. +type IDdlStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CreateDatabase() ICreateDatabaseContext + CreateEvent() ICreateEventContext + CreateIndex() ICreateIndexContext + CreateLogfileGroup() ICreateLogfileGroupContext + CreateProcedure() ICreateProcedureContext + CreateFunction() ICreateFunctionContext + CreateServer() ICreateServerContext + CreateTable() ICreateTableContext + CreateTablespaceInnodb() ICreateTablespaceInnodbContext + CreateTablespaceNdb() ICreateTablespaceNdbContext + CreateTrigger() ICreateTriggerContext + CreateView() ICreateViewContext + CreateRole() ICreateRoleContext + AlterDatabase() IAlterDatabaseContext + AlterEvent() IAlterEventContext + AlterFunction() IAlterFunctionContext + AlterInstance() IAlterInstanceContext + AlterLogfileGroup() IAlterLogfileGroupContext + AlterProcedure() IAlterProcedureContext + AlterServer() IAlterServerContext + AlterTable() IAlterTableContext + AlterTablespace() IAlterTablespaceContext + AlterView() IAlterViewContext + DropDatabase() IDropDatabaseContext + DropEvent() IDropEventContext + DropIndex() IDropIndexContext + DropLogfileGroup() IDropLogfileGroupContext + DropProcedure() IDropProcedureContext + DropFunction() IDropFunctionContext + DropServer() IDropServerContext + DropTable() IDropTableContext + DropTablespace() IDropTablespaceContext + DropTrigger() IDropTriggerContext + DropView() IDropViewContext + DropRole() IDropRoleContext + SetRole() ISetRoleContext + RenameTable() IRenameTableContext + TruncateTable() ITruncateTableContext + + // IsDdlStatementContext differentiates from other interfaces. + IsDdlStatementContext() +} + +type DdlStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDdlStatementContext() *DdlStatementContext { + var p = new(DdlStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_ddlStatement + return p +} + +func InitEmptyDdlStatementContext(p *DdlStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_ddlStatement +} + +func (*DdlStatementContext) IsDdlStatementContext() {} + +func NewDdlStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DdlStatementContext { + var p = new(DdlStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_ddlStatement + + return p +} + +func (s *DdlStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *DdlStatementContext) CreateDatabase() ICreateDatabaseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateDatabaseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateDatabaseContext) +} + +func (s *DdlStatementContext) CreateEvent() ICreateEventContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateEventContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateEventContext) +} + +func (s *DdlStatementContext) CreateIndex() ICreateIndexContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateIndexContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateIndexContext) +} + +func (s *DdlStatementContext) CreateLogfileGroup() ICreateLogfileGroupContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateLogfileGroupContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateLogfileGroupContext) +} + +func (s *DdlStatementContext) CreateProcedure() ICreateProcedureContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateProcedureContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateProcedureContext) +} + +func (s *DdlStatementContext) CreateFunction() ICreateFunctionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateFunctionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateFunctionContext) +} + +func (s *DdlStatementContext) CreateServer() ICreateServerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateServerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateServerContext) +} + +func (s *DdlStatementContext) CreateTable() ICreateTableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateTableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateTableContext) +} + +func (s *DdlStatementContext) CreateTablespaceInnodb() ICreateTablespaceInnodbContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateTablespaceInnodbContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateTablespaceInnodbContext) +} + +func (s *DdlStatementContext) CreateTablespaceNdb() ICreateTablespaceNdbContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateTablespaceNdbContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateTablespaceNdbContext) +} + +func (s *DdlStatementContext) CreateTrigger() ICreateTriggerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateTriggerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateTriggerContext) +} + +func (s *DdlStatementContext) CreateView() ICreateViewContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateViewContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateViewContext) +} + +func (s *DdlStatementContext) CreateRole() ICreateRoleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateRoleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateRoleContext) +} + +func (s *DdlStatementContext) AlterDatabase() IAlterDatabaseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterDatabaseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterDatabaseContext) +} + +func (s *DdlStatementContext) AlterEvent() IAlterEventContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterEventContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterEventContext) +} + +func (s *DdlStatementContext) AlterFunction() IAlterFunctionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterFunctionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterFunctionContext) +} + +func (s *DdlStatementContext) AlterInstance() IAlterInstanceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterInstanceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterInstanceContext) +} + +func (s *DdlStatementContext) AlterLogfileGroup() IAlterLogfileGroupContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterLogfileGroupContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterLogfileGroupContext) +} + +func (s *DdlStatementContext) AlterProcedure() IAlterProcedureContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterProcedureContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterProcedureContext) +} + +func (s *DdlStatementContext) AlterServer() IAlterServerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterServerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterServerContext) +} + +func (s *DdlStatementContext) AlterTable() IAlterTableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterTableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterTableContext) +} + +func (s *DdlStatementContext) AlterTablespace() IAlterTablespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterTablespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterTablespaceContext) +} + +func (s *DdlStatementContext) AlterView() IAlterViewContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterViewContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterViewContext) +} + +func (s *DdlStatementContext) DropDatabase() IDropDatabaseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDropDatabaseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDropDatabaseContext) +} + +func (s *DdlStatementContext) DropEvent() IDropEventContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDropEventContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDropEventContext) +} + +func (s *DdlStatementContext) DropIndex() IDropIndexContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDropIndexContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDropIndexContext) +} + +func (s *DdlStatementContext) DropLogfileGroup() IDropLogfileGroupContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDropLogfileGroupContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDropLogfileGroupContext) +} + +func (s *DdlStatementContext) DropProcedure() IDropProcedureContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDropProcedureContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDropProcedureContext) +} + +func (s *DdlStatementContext) DropFunction() IDropFunctionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDropFunctionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDropFunctionContext) +} + +func (s *DdlStatementContext) DropServer() IDropServerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDropServerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDropServerContext) +} + +func (s *DdlStatementContext) DropTable() IDropTableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDropTableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDropTableContext) +} + +func (s *DdlStatementContext) DropTablespace() IDropTablespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDropTablespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDropTablespaceContext) +} + +func (s *DdlStatementContext) DropTrigger() IDropTriggerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDropTriggerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDropTriggerContext) +} + +func (s *DdlStatementContext) DropView() IDropViewContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDropViewContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDropViewContext) +} + +func (s *DdlStatementContext) DropRole() IDropRoleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDropRoleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDropRoleContext) +} + +func (s *DdlStatementContext) SetRole() ISetRoleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISetRoleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISetRoleContext) +} + +func (s *DdlStatementContext) RenameTable() IRenameTableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRenameTableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRenameTableContext) +} + +func (s *DdlStatementContext) TruncateTable() ITruncateTableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITruncateTableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITruncateTableContext) +} + +func (s *DdlStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DdlStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DdlStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterDdlStatement(s) + } +} + +func (s *DdlStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitDdlStatement(s) + } +} + +func (p *MySqlParser) DdlStatement() (localctx IDdlStatementContext) { + localctx = NewDdlStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 8, MySqlParserRULE_ddlStatement) + p.SetState(805) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 10, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(767) + p.CreateDatabase() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(768) + p.CreateEvent() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(769) + p.CreateIndex() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(770) + p.CreateLogfileGroup() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(771) + p.CreateProcedure() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(772) + p.CreateFunction() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(773) + p.CreateServer() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(774) + p.CreateTable() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(775) + p.CreateTablespaceInnodb() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(776) + p.CreateTablespaceNdb() + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(777) + p.CreateTrigger() + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(778) + p.CreateView() + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(779) + p.CreateRole() + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(780) + p.AlterDatabase() + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(781) + p.AlterEvent() + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(782) + p.AlterFunction() + } + + case 17: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(783) + p.AlterInstance() + } + + case 18: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(784) + p.AlterLogfileGroup() + } + + case 19: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(785) + p.AlterProcedure() + } + + case 20: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(786) + p.AlterServer() + } + + case 21: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(787) + p.AlterTable() + } + + case 22: + p.EnterOuterAlt(localctx, 22) + { + p.SetState(788) + p.AlterTablespace() + } + + case 23: + p.EnterOuterAlt(localctx, 23) + { + p.SetState(789) + p.AlterView() + } + + case 24: + p.EnterOuterAlt(localctx, 24) + { + p.SetState(790) + p.DropDatabase() + } + + case 25: + p.EnterOuterAlt(localctx, 25) + { + p.SetState(791) + p.DropEvent() + } + + case 26: + p.EnterOuterAlt(localctx, 26) + { + p.SetState(792) + p.DropIndex() + } + + case 27: + p.EnterOuterAlt(localctx, 27) + { + p.SetState(793) + p.DropLogfileGroup() + } + + case 28: + p.EnterOuterAlt(localctx, 28) + { + p.SetState(794) + p.DropProcedure() + } + + case 29: + p.EnterOuterAlt(localctx, 29) + { + p.SetState(795) + p.DropFunction() + } + + case 30: + p.EnterOuterAlt(localctx, 30) + { + p.SetState(796) + p.DropServer() + } + + case 31: + p.EnterOuterAlt(localctx, 31) + { + p.SetState(797) + p.DropTable() + } + + case 32: + p.EnterOuterAlt(localctx, 32) + { + p.SetState(798) + p.DropTablespace() + } + + case 33: + p.EnterOuterAlt(localctx, 33) + { + p.SetState(799) + p.DropTrigger() + } + + case 34: + p.EnterOuterAlt(localctx, 34) + { + p.SetState(800) + p.DropView() + } + + case 35: + p.EnterOuterAlt(localctx, 35) + { + p.SetState(801) + p.DropRole() + } + + case 36: + p.EnterOuterAlt(localctx, 36) + { + p.SetState(802) + p.SetRole() + } + + case 37: + p.EnterOuterAlt(localctx, 37) + { + p.SetState(803) + p.RenameTable() + } + + case 38: + p.EnterOuterAlt(localctx, 38) + { + p.SetState(804) + p.TruncateTable() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDmlStatementContext is an interface to support dynamic dispatch. +type IDmlStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SelectStatement() ISelectStatementContext + InsertStatement() IInsertStatementContext + UpdateStatement() IUpdateStatementContext + DeleteStatement() IDeleteStatementContext + ReplaceStatement() IReplaceStatementContext + CallStatement() ICallStatementContext + LoadDataStatement() ILoadDataStatementContext + LoadXmlStatement() ILoadXmlStatementContext + DoStatement() IDoStatementContext + HandlerStatement() IHandlerStatementContext + ValuesStatement() IValuesStatementContext + WithStatement() IWithStatementContext + TableStatement() ITableStatementContext + + // IsDmlStatementContext differentiates from other interfaces. + IsDmlStatementContext() +} + +type DmlStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDmlStatementContext() *DmlStatementContext { + var p = new(DmlStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_dmlStatement + return p +} + +func InitEmptyDmlStatementContext(p *DmlStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_dmlStatement +} + +func (*DmlStatementContext) IsDmlStatementContext() {} + +func NewDmlStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DmlStatementContext { + var p = new(DmlStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_dmlStatement + + return p +} + +func (s *DmlStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *DmlStatementContext) SelectStatement() ISelectStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelectStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelectStatementContext) +} + +func (s *DmlStatementContext) InsertStatement() IInsertStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInsertStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInsertStatementContext) +} + +func (s *DmlStatementContext) UpdateStatement() IUpdateStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdateStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUpdateStatementContext) +} + +func (s *DmlStatementContext) DeleteStatement() IDeleteStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeleteStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDeleteStatementContext) +} + +func (s *DmlStatementContext) ReplaceStatement() IReplaceStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReplaceStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReplaceStatementContext) +} + +func (s *DmlStatementContext) CallStatement() ICallStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICallStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICallStatementContext) +} + +func (s *DmlStatementContext) LoadDataStatement() ILoadDataStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILoadDataStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILoadDataStatementContext) +} + +func (s *DmlStatementContext) LoadXmlStatement() ILoadXmlStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILoadXmlStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILoadXmlStatementContext) +} + +func (s *DmlStatementContext) DoStatement() IDoStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDoStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDoStatementContext) +} + +func (s *DmlStatementContext) HandlerStatement() IHandlerStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHandlerStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHandlerStatementContext) +} + +func (s *DmlStatementContext) ValuesStatement() IValuesStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IValuesStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IValuesStatementContext) +} + +func (s *DmlStatementContext) WithStatement() IWithStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWithStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWithStatementContext) +} + +func (s *DmlStatementContext) TableStatement() ITableStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableStatementContext) +} + +func (s *DmlStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DmlStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DmlStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterDmlStatement(s) + } +} + +func (s *DmlStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitDmlStatement(s) + } +} + +func (p *MySqlParser) DmlStatement() (localctx IDmlStatementContext) { + localctx = NewDmlStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 10, MySqlParserRULE_dmlStatement) + p.SetState(820) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 11, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(807) + p.SelectStatement() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(808) + p.InsertStatement() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(809) + p.UpdateStatement() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(810) + p.DeleteStatement() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(811) + p.ReplaceStatement() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(812) + p.CallStatement() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(813) + p.LoadDataStatement() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(814) + p.LoadXmlStatement() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(815) + p.DoStatement() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(816) + p.HandlerStatement() + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(817) + p.ValuesStatement() + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(818) + p.WithStatement() + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(819) + p.TableStatement() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITransactionStatementContext is an interface to support dynamic dispatch. +type ITransactionStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + StartTransaction() IStartTransactionContext + BeginWork() IBeginWorkContext + CommitWork() ICommitWorkContext + RollbackWork() IRollbackWorkContext + SavepointStatement() ISavepointStatementContext + RollbackStatement() IRollbackStatementContext + ReleaseStatement() IReleaseStatementContext + LockTables() ILockTablesContext + UnlockTables() IUnlockTablesContext + + // IsTransactionStatementContext differentiates from other interfaces. + IsTransactionStatementContext() +} + +type TransactionStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTransactionStatementContext() *TransactionStatementContext { + var p = new(TransactionStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_transactionStatement + return p +} + +func InitEmptyTransactionStatementContext(p *TransactionStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_transactionStatement +} + +func (*TransactionStatementContext) IsTransactionStatementContext() {} + +func NewTransactionStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TransactionStatementContext { + var p = new(TransactionStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_transactionStatement + + return p +} + +func (s *TransactionStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *TransactionStatementContext) StartTransaction() IStartTransactionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStartTransactionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStartTransactionContext) +} + +func (s *TransactionStatementContext) BeginWork() IBeginWorkContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBeginWorkContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBeginWorkContext) +} + +func (s *TransactionStatementContext) CommitWork() ICommitWorkContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICommitWorkContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICommitWorkContext) +} + +func (s *TransactionStatementContext) RollbackWork() IRollbackWorkContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRollbackWorkContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRollbackWorkContext) +} + +func (s *TransactionStatementContext) SavepointStatement() ISavepointStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISavepointStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISavepointStatementContext) +} + +func (s *TransactionStatementContext) RollbackStatement() IRollbackStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRollbackStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRollbackStatementContext) +} + +func (s *TransactionStatementContext) ReleaseStatement() IReleaseStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReleaseStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReleaseStatementContext) +} + +func (s *TransactionStatementContext) LockTables() ILockTablesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILockTablesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILockTablesContext) +} + +func (s *TransactionStatementContext) UnlockTables() IUnlockTablesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnlockTablesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnlockTablesContext) +} + +func (s *TransactionStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TransactionStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TransactionStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTransactionStatement(s) + } +} + +func (s *TransactionStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTransactionStatement(s) + } +} + +func (p *MySqlParser) TransactionStatement() (localctx ITransactionStatementContext) { + localctx = NewTransactionStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 12, MySqlParserRULE_transactionStatement) + p.SetState(831) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 12, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(822) + p.StartTransaction() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(823) + p.BeginWork() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(824) + p.CommitWork() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(825) + p.RollbackWork() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(826) + p.SavepointStatement() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(827) + p.RollbackStatement() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(828) + p.ReleaseStatement() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(829) + p.LockTables() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(830) + p.UnlockTables() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReplicationStatementContext is an interface to support dynamic dispatch. +type IReplicationStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ChangeMaster() IChangeMasterContext + ChangeReplicationFilter() IChangeReplicationFilterContext + PurgeBinaryLogs() IPurgeBinaryLogsContext + ResetMaster() IResetMasterContext + ResetSlave() IResetSlaveContext + StartSlave() IStartSlaveContext + StopSlave() IStopSlaveContext + StartGroupReplication() IStartGroupReplicationContext + StopGroupReplication() IStopGroupReplicationContext + XaStartTransaction() IXaStartTransactionContext + XaEndTransaction() IXaEndTransactionContext + XaPrepareStatement() IXaPrepareStatementContext + XaCommitWork() IXaCommitWorkContext + XaRollbackWork() IXaRollbackWorkContext + XaRecoverWork() IXaRecoverWorkContext + + // IsReplicationStatementContext differentiates from other interfaces. + IsReplicationStatementContext() +} + +type ReplicationStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReplicationStatementContext() *ReplicationStatementContext { + var p = new(ReplicationStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_replicationStatement + return p +} + +func InitEmptyReplicationStatementContext(p *ReplicationStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_replicationStatement +} + +func (*ReplicationStatementContext) IsReplicationStatementContext() {} + +func NewReplicationStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReplicationStatementContext { + var p = new(ReplicationStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_replicationStatement + + return p +} + +func (s *ReplicationStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *ReplicationStatementContext) ChangeMaster() IChangeMasterContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IChangeMasterContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IChangeMasterContext) +} + +func (s *ReplicationStatementContext) ChangeReplicationFilter() IChangeReplicationFilterContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IChangeReplicationFilterContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IChangeReplicationFilterContext) +} + +func (s *ReplicationStatementContext) PurgeBinaryLogs() IPurgeBinaryLogsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPurgeBinaryLogsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPurgeBinaryLogsContext) +} + +func (s *ReplicationStatementContext) ResetMaster() IResetMasterContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IResetMasterContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IResetMasterContext) +} + +func (s *ReplicationStatementContext) ResetSlave() IResetSlaveContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IResetSlaveContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IResetSlaveContext) +} + +func (s *ReplicationStatementContext) StartSlave() IStartSlaveContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStartSlaveContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStartSlaveContext) +} + +func (s *ReplicationStatementContext) StopSlave() IStopSlaveContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStopSlaveContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStopSlaveContext) +} + +func (s *ReplicationStatementContext) StartGroupReplication() IStartGroupReplicationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStartGroupReplicationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStartGroupReplicationContext) +} + +func (s *ReplicationStatementContext) StopGroupReplication() IStopGroupReplicationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStopGroupReplicationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStopGroupReplicationContext) +} + +func (s *ReplicationStatementContext) XaStartTransaction() IXaStartTransactionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXaStartTransactionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXaStartTransactionContext) +} + +func (s *ReplicationStatementContext) XaEndTransaction() IXaEndTransactionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXaEndTransactionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXaEndTransactionContext) +} + +func (s *ReplicationStatementContext) XaPrepareStatement() IXaPrepareStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXaPrepareStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXaPrepareStatementContext) +} + +func (s *ReplicationStatementContext) XaCommitWork() IXaCommitWorkContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXaCommitWorkContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXaCommitWorkContext) +} + +func (s *ReplicationStatementContext) XaRollbackWork() IXaRollbackWorkContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXaRollbackWorkContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXaRollbackWorkContext) +} + +func (s *ReplicationStatementContext) XaRecoverWork() IXaRecoverWorkContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXaRecoverWorkContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXaRecoverWorkContext) +} + +func (s *ReplicationStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ReplicationStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ReplicationStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterReplicationStatement(s) + } +} + +func (s *ReplicationStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitReplicationStatement(s) + } +} + +func (p *MySqlParser) ReplicationStatement() (localctx IReplicationStatementContext) { + localctx = NewReplicationStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 14, MySqlParserRULE_replicationStatement) + p.SetState(848) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 13, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(833) + p.ChangeMaster() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(834) + p.ChangeReplicationFilter() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(835) + p.PurgeBinaryLogs() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(836) + p.ResetMaster() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(837) + p.ResetSlave() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(838) + p.StartSlave() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(839) + p.StopSlave() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(840) + p.StartGroupReplication() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(841) + p.StopGroupReplication() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(842) + p.XaStartTransaction() + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(843) + p.XaEndTransaction() + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(844) + p.XaPrepareStatement() + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(845) + p.XaCommitWork() + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(846) + p.XaRollbackWork() + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(847) + p.XaRecoverWork() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPreparedStatementContext is an interface to support dynamic dispatch. +type IPreparedStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PrepareStatement() IPrepareStatementContext + ExecuteStatement() IExecuteStatementContext + DeallocatePrepare() IDeallocatePrepareContext + + // IsPreparedStatementContext differentiates from other interfaces. + IsPreparedStatementContext() +} + +type PreparedStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPreparedStatementContext() *PreparedStatementContext { + var p = new(PreparedStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_preparedStatement + return p +} + +func InitEmptyPreparedStatementContext(p *PreparedStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_preparedStatement +} + +func (*PreparedStatementContext) IsPreparedStatementContext() {} + +func NewPreparedStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PreparedStatementContext { + var p = new(PreparedStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_preparedStatement + + return p +} + +func (s *PreparedStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *PreparedStatementContext) PrepareStatement() IPrepareStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrepareStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrepareStatementContext) +} + +func (s *PreparedStatementContext) ExecuteStatement() IExecuteStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExecuteStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExecuteStatementContext) +} + +func (s *PreparedStatementContext) DeallocatePrepare() IDeallocatePrepareContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeallocatePrepareContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDeallocatePrepareContext) +} + +func (s *PreparedStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PreparedStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PreparedStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterPreparedStatement(s) + } +} + +func (s *PreparedStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitPreparedStatement(s) + } +} + +func (p *MySqlParser) PreparedStatement() (localctx IPreparedStatementContext) { + localctx = NewPreparedStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 16, MySqlParserRULE_preparedStatement) + p.SetState(853) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserPREPARE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(850) + p.PrepareStatement() + } + + case MySqlParserEXECUTE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(851) + p.ExecuteStatement() + } + + case MySqlParserDROP, MySqlParserDEALLOCATE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(852) + p.DeallocatePrepare() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICompoundStatementContext is an interface to support dynamic dispatch. +type ICompoundStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BlockStatement() IBlockStatementContext + CaseStatement() ICaseStatementContext + IfStatement() IIfStatementContext + LeaveStatement() ILeaveStatementContext + LoopStatement() ILoopStatementContext + RepeatStatement() IRepeatStatementContext + WhileStatement() IWhileStatementContext + IterateStatement() IIterateStatementContext + ReturnStatement() IReturnStatementContext + CursorStatement() ICursorStatementContext + WithStatement() IWithStatementContext + DmlStatement() IDmlStatementContext + + // IsCompoundStatementContext differentiates from other interfaces. + IsCompoundStatementContext() +} + +type CompoundStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCompoundStatementContext() *CompoundStatementContext { + var p = new(CompoundStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_compoundStatement + return p +} + +func InitEmptyCompoundStatementContext(p *CompoundStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_compoundStatement +} + +func (*CompoundStatementContext) IsCompoundStatementContext() {} + +func NewCompoundStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CompoundStatementContext { + var p = new(CompoundStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_compoundStatement + + return p +} + +func (s *CompoundStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *CompoundStatementContext) BlockStatement() IBlockStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBlockStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBlockStatementContext) +} + +func (s *CompoundStatementContext) CaseStatement() ICaseStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICaseStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICaseStatementContext) +} + +func (s *CompoundStatementContext) IfStatement() IIfStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfStatementContext) +} + +func (s *CompoundStatementContext) LeaveStatement() ILeaveStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILeaveStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILeaveStatementContext) +} + +func (s *CompoundStatementContext) LoopStatement() ILoopStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILoopStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILoopStatementContext) +} + +func (s *CompoundStatementContext) RepeatStatement() IRepeatStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRepeatStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRepeatStatementContext) +} + +func (s *CompoundStatementContext) WhileStatement() IWhileStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhileStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhileStatementContext) +} + +func (s *CompoundStatementContext) IterateStatement() IIterateStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIterateStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIterateStatementContext) +} + +func (s *CompoundStatementContext) ReturnStatement() IReturnStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReturnStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReturnStatementContext) +} + +func (s *CompoundStatementContext) CursorStatement() ICursorStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICursorStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICursorStatementContext) +} + +func (s *CompoundStatementContext) WithStatement() IWithStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWithStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWithStatementContext) +} + +func (s *CompoundStatementContext) DmlStatement() IDmlStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDmlStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDmlStatementContext) +} + +func (s *CompoundStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CompoundStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CompoundStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCompoundStatement(s) + } +} + +func (s *CompoundStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCompoundStatement(s) + } +} + +func (p *MySqlParser) CompoundStatement() (localctx ICompoundStatementContext) { + localctx = NewCompoundStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 18, MySqlParserRULE_compoundStatement) + p.SetState(868) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 15, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(855) + p.BlockStatement() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(856) + p.CaseStatement() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(857) + p.IfStatement() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(858) + p.LeaveStatement() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(859) + p.LoopStatement() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(860) + p.RepeatStatement() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(861) + p.WhileStatement() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(862) + p.IterateStatement() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(863) + p.ReturnStatement() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(864) + p.CursorStatement() + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(865) + p.WithStatement() + } + { + p.SetState(866) + p.DmlStatement() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAdministrationStatementContext is an interface to support dynamic dispatch. +type IAdministrationStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AlterUser() IAlterUserContext + CreateUser() ICreateUserContext + DropUser() IDropUserContext + GrantStatement() IGrantStatementContext + GrantProxy() IGrantProxyContext + RenameUser() IRenameUserContext + RevokeStatement() IRevokeStatementContext + RevokeProxy() IRevokeProxyContext + AnalyzeTable() IAnalyzeTableContext + CheckTable() ICheckTableContext + ChecksumTable() IChecksumTableContext + OptimizeTable() IOptimizeTableContext + RepairTable() IRepairTableContext + CreateUdfunction() ICreateUdfunctionContext + InstallPlugin() IInstallPluginContext + UninstallPlugin() IUninstallPluginContext + SetStatement() ISetStatementContext + ShowStatement() IShowStatementContext + BinlogStatement() IBinlogStatementContext + CacheIndexStatement() ICacheIndexStatementContext + FlushStatement() IFlushStatementContext + KillStatement() IKillStatementContext + LoadIndexIntoCache() ILoadIndexIntoCacheContext + ResetStatement() IResetStatementContext + ShutdownStatement() IShutdownStatementContext + + // IsAdministrationStatementContext differentiates from other interfaces. + IsAdministrationStatementContext() +} + +type AdministrationStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAdministrationStatementContext() *AdministrationStatementContext { + var p = new(AdministrationStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_administrationStatement + return p +} + +func InitEmptyAdministrationStatementContext(p *AdministrationStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_administrationStatement +} + +func (*AdministrationStatementContext) IsAdministrationStatementContext() {} + +func NewAdministrationStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AdministrationStatementContext { + var p = new(AdministrationStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_administrationStatement + + return p +} + +func (s *AdministrationStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *AdministrationStatementContext) AlterUser() IAlterUserContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterUserContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterUserContext) +} + +func (s *AdministrationStatementContext) CreateUser() ICreateUserContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateUserContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateUserContext) +} + +func (s *AdministrationStatementContext) DropUser() IDropUserContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDropUserContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDropUserContext) +} + +func (s *AdministrationStatementContext) GrantStatement() IGrantStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrantStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrantStatementContext) +} + +func (s *AdministrationStatementContext) GrantProxy() IGrantProxyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrantProxyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrantProxyContext) +} + +func (s *AdministrationStatementContext) RenameUser() IRenameUserContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRenameUserContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRenameUserContext) +} + +func (s *AdministrationStatementContext) RevokeStatement() IRevokeStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRevokeStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRevokeStatementContext) +} + +func (s *AdministrationStatementContext) RevokeProxy() IRevokeProxyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRevokeProxyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRevokeProxyContext) +} + +func (s *AdministrationStatementContext) AnalyzeTable() IAnalyzeTableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnalyzeTableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAnalyzeTableContext) +} + +func (s *AdministrationStatementContext) CheckTable() ICheckTableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICheckTableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICheckTableContext) +} + +func (s *AdministrationStatementContext) ChecksumTable() IChecksumTableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IChecksumTableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IChecksumTableContext) +} + +func (s *AdministrationStatementContext) OptimizeTable() IOptimizeTableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOptimizeTableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOptimizeTableContext) +} + +func (s *AdministrationStatementContext) RepairTable() IRepairTableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRepairTableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRepairTableContext) +} + +func (s *AdministrationStatementContext) CreateUdfunction() ICreateUdfunctionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateUdfunctionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateUdfunctionContext) +} + +func (s *AdministrationStatementContext) InstallPlugin() IInstallPluginContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInstallPluginContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInstallPluginContext) +} + +func (s *AdministrationStatementContext) UninstallPlugin() IUninstallPluginContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUninstallPluginContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUninstallPluginContext) +} + +func (s *AdministrationStatementContext) SetStatement() ISetStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISetStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISetStatementContext) +} + +func (s *AdministrationStatementContext) ShowStatement() IShowStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShowStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShowStatementContext) +} + +func (s *AdministrationStatementContext) BinlogStatement() IBinlogStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBinlogStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBinlogStatementContext) +} + +func (s *AdministrationStatementContext) CacheIndexStatement() ICacheIndexStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICacheIndexStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICacheIndexStatementContext) +} + +func (s *AdministrationStatementContext) FlushStatement() IFlushStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFlushStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFlushStatementContext) +} + +func (s *AdministrationStatementContext) KillStatement() IKillStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKillStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKillStatementContext) +} + +func (s *AdministrationStatementContext) LoadIndexIntoCache() ILoadIndexIntoCacheContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILoadIndexIntoCacheContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILoadIndexIntoCacheContext) +} + +func (s *AdministrationStatementContext) ResetStatement() IResetStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IResetStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IResetStatementContext) +} + +func (s *AdministrationStatementContext) ShutdownStatement() IShutdownStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShutdownStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShutdownStatementContext) +} + +func (s *AdministrationStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AdministrationStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AdministrationStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAdministrationStatement(s) + } +} + +func (s *AdministrationStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAdministrationStatement(s) + } +} + +func (p *MySqlParser) AdministrationStatement() (localctx IAdministrationStatementContext) { + localctx = NewAdministrationStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 20, MySqlParserRULE_administrationStatement) + p.SetState(895) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 16, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(870) + p.AlterUser() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(871) + p.CreateUser() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(872) + p.DropUser() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(873) + p.GrantStatement() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(874) + p.GrantProxy() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(875) + p.RenameUser() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(876) + p.RevokeStatement() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(877) + p.RevokeProxy() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(878) + p.AnalyzeTable() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(879) + p.CheckTable() + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(880) + p.ChecksumTable() + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(881) + p.OptimizeTable() + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(882) + p.RepairTable() + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(883) + p.CreateUdfunction() + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(884) + p.InstallPlugin() + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(885) + p.UninstallPlugin() + } + + case 17: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(886) + p.SetStatement() + } + + case 18: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(887) + p.ShowStatement() + } + + case 19: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(888) + p.BinlogStatement() + } + + case 20: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(889) + p.CacheIndexStatement() + } + + case 21: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(890) + p.FlushStatement() + } + + case 22: + p.EnterOuterAlt(localctx, 22) + { + p.SetState(891) + p.KillStatement() + } + + case 23: + p.EnterOuterAlt(localctx, 23) + { + p.SetState(892) + p.LoadIndexIntoCache() + } + + case 24: + p.EnterOuterAlt(localctx, 24) + { + p.SetState(893) + p.ResetStatement() + } + + case 25: + p.EnterOuterAlt(localctx, 25) + { + p.SetState(894) + p.ShutdownStatement() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUtilityStatementContext is an interface to support dynamic dispatch. +type IUtilityStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SimpleDescribeStatement() ISimpleDescribeStatementContext + FullDescribeStatement() IFullDescribeStatementContext + HelpStatement() IHelpStatementContext + UseStatement() IUseStatementContext + SignalStatement() ISignalStatementContext + ResignalStatement() IResignalStatementContext + DiagnosticsStatement() IDiagnosticsStatementContext + + // IsUtilityStatementContext differentiates from other interfaces. + IsUtilityStatementContext() +} + +type UtilityStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUtilityStatementContext() *UtilityStatementContext { + var p = new(UtilityStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_utilityStatement + return p +} + +func InitEmptyUtilityStatementContext(p *UtilityStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_utilityStatement +} + +func (*UtilityStatementContext) IsUtilityStatementContext() {} + +func NewUtilityStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UtilityStatementContext { + var p = new(UtilityStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_utilityStatement + + return p +} + +func (s *UtilityStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *UtilityStatementContext) SimpleDescribeStatement() ISimpleDescribeStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimpleDescribeStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISimpleDescribeStatementContext) +} + +func (s *UtilityStatementContext) FullDescribeStatement() IFullDescribeStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFullDescribeStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFullDescribeStatementContext) +} + +func (s *UtilityStatementContext) HelpStatement() IHelpStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHelpStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHelpStatementContext) +} + +func (s *UtilityStatementContext) UseStatement() IUseStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUseStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUseStatementContext) +} + +func (s *UtilityStatementContext) SignalStatement() ISignalStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISignalStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISignalStatementContext) +} + +func (s *UtilityStatementContext) ResignalStatement() IResignalStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IResignalStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IResignalStatementContext) +} + +func (s *UtilityStatementContext) DiagnosticsStatement() IDiagnosticsStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDiagnosticsStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDiagnosticsStatementContext) +} + +func (s *UtilityStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UtilityStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *UtilityStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterUtilityStatement(s) + } +} + +func (s *UtilityStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitUtilityStatement(s) + } +} + +func (p *MySqlParser) UtilityStatement() (localctx IUtilityStatementContext) { + localctx = NewUtilityStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 22, MySqlParserRULE_utilityStatement) + p.SetState(904) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 17, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(897) + p.SimpleDescribeStatement() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(898) + p.FullDescribeStatement() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(899) + p.HelpStatement() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(900) + p.UseStatement() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(901) + p.SignalStatement() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(902) + p.ResignalStatement() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(903) + p.DiagnosticsStatement() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreateDatabaseContext is an interface to support dynamic dispatch. +type ICreateDatabaseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetDbFormat returns the dbFormat token. + GetDbFormat() antlr.Token + + // SetDbFormat sets the dbFormat token. + SetDbFormat(antlr.Token) + + // Getter signatures + CREATE() antlr.TerminalNode + Uid() IUidContext + DATABASE() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + IfNotExists() IIfNotExistsContext + AllCreateDatabaseOption() []ICreateDatabaseOptionContext + CreateDatabaseOption(i int) ICreateDatabaseOptionContext + + // IsCreateDatabaseContext differentiates from other interfaces. + IsCreateDatabaseContext() +} + +type CreateDatabaseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + dbFormat antlr.Token +} + +func NewEmptyCreateDatabaseContext() *CreateDatabaseContext { + var p = new(CreateDatabaseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_createDatabase + return p +} + +func InitEmptyCreateDatabaseContext(p *CreateDatabaseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_createDatabase +} + +func (*CreateDatabaseContext) IsCreateDatabaseContext() {} + +func NewCreateDatabaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateDatabaseContext { + var p = new(CreateDatabaseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_createDatabase + + return p +} + +func (s *CreateDatabaseContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateDatabaseContext) GetDbFormat() antlr.Token { return s.dbFormat } + +func (s *CreateDatabaseContext) SetDbFormat(v antlr.Token) { s.dbFormat = v } + +func (s *CreateDatabaseContext) CREATE() antlr.TerminalNode { + return s.GetToken(MySqlParserCREATE, 0) +} + +func (s *CreateDatabaseContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *CreateDatabaseContext) DATABASE() antlr.TerminalNode { + return s.GetToken(MySqlParserDATABASE, 0) +} + +func (s *CreateDatabaseContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(MySqlParserSCHEMA, 0) +} + +func (s *CreateDatabaseContext) IfNotExists() IIfNotExistsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfNotExistsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfNotExistsContext) +} + +func (s *CreateDatabaseContext) AllCreateDatabaseOption() []ICreateDatabaseOptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICreateDatabaseOptionContext); ok { + len++ + } + } + + tst := make([]ICreateDatabaseOptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICreateDatabaseOptionContext); ok { + tst[i] = t.(ICreateDatabaseOptionContext) + i++ + } + } + + return tst +} + +func (s *CreateDatabaseContext) CreateDatabaseOption(i int) ICreateDatabaseOptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateDatabaseOptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICreateDatabaseOptionContext) +} + +func (s *CreateDatabaseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateDatabaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateDatabaseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCreateDatabase(s) + } +} + +func (s *CreateDatabaseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCreateDatabase(s) + } +} + +func (p *MySqlParser) CreateDatabase() (localctx ICreateDatabaseContext) { + localctx = NewCreateDatabaseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 24, MySqlParserRULE_createDatabase) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(906) + p.Match(MySqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(907) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*CreateDatabaseContext).dbFormat = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserDATABASE || _la == MySqlParserSCHEMA) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*CreateDatabaseContext).dbFormat = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(909) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 18, p.GetParserRuleContext()) == 1 { + { + p.SetState(908) + p.IfNotExists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(911) + p.Uid() + } + p.SetState(915) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&4398214283264) != 0) || _la == MySqlParserREAD || _la == MySqlParserCHAR || _la == MySqlParserENCRYPTION || _la == MySqlParserCHARSET { + { + p.SetState(912) + p.CreateDatabaseOption() + } + + p.SetState(917) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreateEventContext is an interface to support dynamic dispatch. +type ICreateEventContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + EVENT() antlr.TerminalNode + FullId() IFullIdContext + AllON() []antlr.TerminalNode + ON(i int) antlr.TerminalNode + SCHEDULE() antlr.TerminalNode + ScheduleExpression() IScheduleExpressionContext + DO() antlr.TerminalNode + RoutineBody() IRoutineBodyContext + OwnerStatement() IOwnerStatementContext + IfNotExists() IIfNotExistsContext + COMPLETION() antlr.TerminalNode + PRESERVE() antlr.TerminalNode + EnableType() IEnableTypeContext + COMMENT() antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + NOT() antlr.TerminalNode + + // IsCreateEventContext differentiates from other interfaces. + IsCreateEventContext() +} + +type CreateEventContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreateEventContext() *CreateEventContext { + var p = new(CreateEventContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_createEvent + return p +} + +func InitEmptyCreateEventContext(p *CreateEventContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_createEvent +} + +func (*CreateEventContext) IsCreateEventContext() {} + +func NewCreateEventContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateEventContext { + var p = new(CreateEventContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_createEvent + + return p +} + +func (s *CreateEventContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateEventContext) CREATE() antlr.TerminalNode { + return s.GetToken(MySqlParserCREATE, 0) +} + +func (s *CreateEventContext) EVENT() antlr.TerminalNode { + return s.GetToken(MySqlParserEVENT, 0) +} + +func (s *CreateEventContext) FullId() IFullIdContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFullIdContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFullIdContext) +} + +func (s *CreateEventContext) AllON() []antlr.TerminalNode { + return s.GetTokens(MySqlParserON) +} + +func (s *CreateEventContext) ON(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserON, i) +} + +func (s *CreateEventContext) SCHEDULE() antlr.TerminalNode { + return s.GetToken(MySqlParserSCHEDULE, 0) +} + +func (s *CreateEventContext) ScheduleExpression() IScheduleExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IScheduleExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IScheduleExpressionContext) +} + +func (s *CreateEventContext) DO() antlr.TerminalNode { + return s.GetToken(MySqlParserDO, 0) +} + +func (s *CreateEventContext) RoutineBody() IRoutineBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRoutineBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRoutineBodyContext) +} + +func (s *CreateEventContext) OwnerStatement() IOwnerStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOwnerStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOwnerStatementContext) +} + +func (s *CreateEventContext) IfNotExists() IIfNotExistsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfNotExistsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfNotExistsContext) +} + +func (s *CreateEventContext) COMPLETION() antlr.TerminalNode { + return s.GetToken(MySqlParserCOMPLETION, 0) +} + +func (s *CreateEventContext) PRESERVE() antlr.TerminalNode { + return s.GetToken(MySqlParserPRESERVE, 0) +} + +func (s *CreateEventContext) EnableType() IEnableTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEnableTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEnableTypeContext) +} + +func (s *CreateEventContext) COMMENT() antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMENT, 0) +} + +func (s *CreateEventContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *CreateEventContext) NOT() antlr.TerminalNode { + return s.GetToken(MySqlParserNOT, 0) +} + +func (s *CreateEventContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateEventContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateEventContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCreateEvent(s) + } +} + +func (s *CreateEventContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCreateEvent(s) + } +} + +func (p *MySqlParser) CreateEvent() (localctx ICreateEventContext) { + localctx = NewCreateEventContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 26, MySqlParserRULE_createEvent) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(918) + p.Match(MySqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(920) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserDEFINER { + { + p.SetState(919) + p.OwnerStatement() + } + + } + { + p.SetState(922) + p.Match(MySqlParserEVENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(924) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 21, p.GetParserRuleContext()) == 1 { + { + p.SetState(923) + p.IfNotExists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(926) + p.FullId() + } + { + p.SetState(927) + p.Match(MySqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(928) + p.Match(MySqlParserSCHEDULE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(929) + p.ScheduleExpression() + } + p.SetState(936) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserON { + { + p.SetState(930) + p.Match(MySqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(931) + p.Match(MySqlParserCOMPLETION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(933) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserNOT { + { + p.SetState(932) + p.Match(MySqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(935) + p.Match(MySqlParserPRESERVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(939) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserDISABLE || _la == MySqlParserENABLE { + { + p.SetState(938) + p.EnableType() + } + + } + p.SetState(943) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserCOMMENT { + { + p.SetState(941) + p.Match(MySqlParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(942) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(945) + p.Match(MySqlParserDO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(946) + p.RoutineBody() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreateIndexContext is an interface to support dynamic dispatch. +type ICreateIndexContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetIntimeAction returns the intimeAction token. + GetIntimeAction() antlr.Token + + // GetIndexCategory returns the indexCategory token. + GetIndexCategory() antlr.Token + + // GetAlgType returns the algType token. + GetAlgType() antlr.Token + + // GetLockType returns the lockType token. + GetLockType() antlr.Token + + // SetIntimeAction sets the intimeAction token. + SetIntimeAction(antlr.Token) + + // SetIndexCategory sets the indexCategory token. + SetIndexCategory(antlr.Token) + + // SetAlgType sets the algType token. + SetAlgType(antlr.Token) + + // SetLockType sets the lockType token. + SetLockType(antlr.Token) + + // Getter signatures + CREATE() antlr.TerminalNode + INDEX() antlr.TerminalNode + Uid() IUidContext + ON() antlr.TerminalNode + TableName() ITableNameContext + IndexColumnNames() IIndexColumnNamesContext + IndexType() IIndexTypeContext + AllIndexOption() []IIndexOptionContext + IndexOption(i int) IIndexOptionContext + AllALGORITHM() []antlr.TerminalNode + ALGORITHM(i int) antlr.TerminalNode + AllLOCK() []antlr.TerminalNode + LOCK(i int) antlr.TerminalNode + ONLINE() antlr.TerminalNode + OFFLINE() antlr.TerminalNode + UNIQUE() antlr.TerminalNode + FULLTEXT() antlr.TerminalNode + SPATIAL() antlr.TerminalNode + AllDEFAULT() []antlr.TerminalNode + DEFAULT(i int) antlr.TerminalNode + AllINPLACE() []antlr.TerminalNode + INPLACE(i int) antlr.TerminalNode + AllCOPY() []antlr.TerminalNode + COPY(i int) antlr.TerminalNode + AllNONE() []antlr.TerminalNode + NONE(i int) antlr.TerminalNode + AllSHARED() []antlr.TerminalNode + SHARED(i int) antlr.TerminalNode + AllEXCLUSIVE() []antlr.TerminalNode + EXCLUSIVE(i int) antlr.TerminalNode + AllEQUAL_SYMBOL() []antlr.TerminalNode + EQUAL_SYMBOL(i int) antlr.TerminalNode + + // IsCreateIndexContext differentiates from other interfaces. + IsCreateIndexContext() +} + +type CreateIndexContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + intimeAction antlr.Token + indexCategory antlr.Token + algType antlr.Token + lockType antlr.Token +} + +func NewEmptyCreateIndexContext() *CreateIndexContext { + var p = new(CreateIndexContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_createIndex + return p +} + +func InitEmptyCreateIndexContext(p *CreateIndexContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_createIndex +} + +func (*CreateIndexContext) IsCreateIndexContext() {} + +func NewCreateIndexContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateIndexContext { + var p = new(CreateIndexContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_createIndex + + return p +} + +func (s *CreateIndexContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateIndexContext) GetIntimeAction() antlr.Token { return s.intimeAction } + +func (s *CreateIndexContext) GetIndexCategory() antlr.Token { return s.indexCategory } + +func (s *CreateIndexContext) GetAlgType() antlr.Token { return s.algType } + +func (s *CreateIndexContext) GetLockType() antlr.Token { return s.lockType } + +func (s *CreateIndexContext) SetIntimeAction(v antlr.Token) { s.intimeAction = v } + +func (s *CreateIndexContext) SetIndexCategory(v antlr.Token) { s.indexCategory = v } + +func (s *CreateIndexContext) SetAlgType(v antlr.Token) { s.algType = v } + +func (s *CreateIndexContext) SetLockType(v antlr.Token) { s.lockType = v } + +func (s *CreateIndexContext) CREATE() antlr.TerminalNode { + return s.GetToken(MySqlParserCREATE, 0) +} + +func (s *CreateIndexContext) INDEX() antlr.TerminalNode { + return s.GetToken(MySqlParserINDEX, 0) +} + +func (s *CreateIndexContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *CreateIndexContext) ON() antlr.TerminalNode { + return s.GetToken(MySqlParserON, 0) +} + +func (s *CreateIndexContext) TableName() ITableNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableNameContext) +} + +func (s *CreateIndexContext) IndexColumnNames() IIndexColumnNamesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexColumnNamesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndexColumnNamesContext) +} + +func (s *CreateIndexContext) IndexType() IIndexTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndexTypeContext) +} + +func (s *CreateIndexContext) AllIndexOption() []IIndexOptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIndexOptionContext); ok { + len++ + } + } + + tst := make([]IIndexOptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIndexOptionContext); ok { + tst[i] = t.(IIndexOptionContext) + i++ + } + } + + return tst +} + +func (s *CreateIndexContext) IndexOption(i int) IIndexOptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexOptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIndexOptionContext) +} + +func (s *CreateIndexContext) AllALGORITHM() []antlr.TerminalNode { + return s.GetTokens(MySqlParserALGORITHM) +} + +func (s *CreateIndexContext) ALGORITHM(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserALGORITHM, i) +} + +func (s *CreateIndexContext) AllLOCK() []antlr.TerminalNode { + return s.GetTokens(MySqlParserLOCK) +} + +func (s *CreateIndexContext) LOCK(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserLOCK, i) +} + +func (s *CreateIndexContext) ONLINE() antlr.TerminalNode { + return s.GetToken(MySqlParserONLINE, 0) +} + +func (s *CreateIndexContext) OFFLINE() antlr.TerminalNode { + return s.GetToken(MySqlParserOFFLINE, 0) +} + +func (s *CreateIndexContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(MySqlParserUNIQUE, 0) +} + +func (s *CreateIndexContext) FULLTEXT() antlr.TerminalNode { + return s.GetToken(MySqlParserFULLTEXT, 0) +} + +func (s *CreateIndexContext) SPATIAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSPATIAL, 0) +} + +func (s *CreateIndexContext) AllDEFAULT() []antlr.TerminalNode { + return s.GetTokens(MySqlParserDEFAULT) +} + +func (s *CreateIndexContext) DEFAULT(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserDEFAULT, i) +} + +func (s *CreateIndexContext) AllINPLACE() []antlr.TerminalNode { + return s.GetTokens(MySqlParserINPLACE) +} + +func (s *CreateIndexContext) INPLACE(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserINPLACE, i) +} + +func (s *CreateIndexContext) AllCOPY() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOPY) +} + +func (s *CreateIndexContext) COPY(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOPY, i) +} + +func (s *CreateIndexContext) AllNONE() []antlr.TerminalNode { + return s.GetTokens(MySqlParserNONE) +} + +func (s *CreateIndexContext) NONE(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserNONE, i) +} + +func (s *CreateIndexContext) AllSHARED() []antlr.TerminalNode { + return s.GetTokens(MySqlParserSHARED) +} + +func (s *CreateIndexContext) SHARED(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserSHARED, i) +} + +func (s *CreateIndexContext) AllEXCLUSIVE() []antlr.TerminalNode { + return s.GetTokens(MySqlParserEXCLUSIVE) +} + +func (s *CreateIndexContext) EXCLUSIVE(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserEXCLUSIVE, i) +} + +func (s *CreateIndexContext) AllEQUAL_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(MySqlParserEQUAL_SYMBOL) +} + +func (s *CreateIndexContext) EQUAL_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, i) +} + +func (s *CreateIndexContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateIndexContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateIndexContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCreateIndex(s) + } +} + +func (s *CreateIndexContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCreateIndex(s) + } +} + +func (p *MySqlParser) CreateIndex() (localctx ICreateIndexContext) { + localctx = NewCreateIndexContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 28, MySqlParserRULE_createIndex) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(948) + p.Match(MySqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(950) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserOFFLINE || _la == MySqlParserONLINE { + { + p.SetState(949) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*CreateIndexContext).intimeAction = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserOFFLINE || _la == MySqlParserONLINE) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*CreateIndexContext).intimeAction = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(953) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserFULLTEXT || _la == MySqlParserSPATIAL || _la == MySqlParserUNIQUE { + { + p.SetState(952) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*CreateIndexContext).indexCategory = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserFULLTEXT || _la == MySqlParserSPATIAL || _la == MySqlParserUNIQUE) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*CreateIndexContext).indexCategory = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(955) + p.Match(MySqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(956) + p.Uid() + } + p.SetState(958) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserUSING { + { + p.SetState(957) + p.IndexType() + } + + } + { + p.SetState(960) + p.Match(MySqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(961) + p.TableName() + } + { + p.SetState(962) + p.IndexColumnNames() + } + p.SetState(966) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 29, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(963) + p.IndexOption() + } + + } + p.SetState(968) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 29, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(981) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 33, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(979) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserALGORITHM: + { + p.SetState(969) + p.Match(MySqlParserALGORITHM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(971) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(970) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(973) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*CreateIndexContext).algType = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserDEFAULT || _la == MySqlParserCOPY || _la == MySqlParserINPLACE) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*CreateIndexContext).algType = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case MySqlParserLOCK: + { + p.SetState(974) + p.Match(MySqlParserLOCK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(976) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(975) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(978) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*CreateIndexContext).lockType = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserDEFAULT || _la == MySqlParserEXCLUSIVE || _la == MySqlParserNONE || _la == MySqlParserSHARED) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*CreateIndexContext).lockType = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(983) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 33, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreateLogfileGroupContext is an interface to support dynamic dispatch. +type ICreateLogfileGroupContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetUndoFile returns the undoFile token. + GetUndoFile() antlr.Token + + // GetComment returns the comment token. + GetComment() antlr.Token + + // SetUndoFile sets the undoFile token. + SetUndoFile(antlr.Token) + + // SetComment sets the comment token. + SetComment(antlr.Token) + + // GetInitSize returns the initSize rule contexts. + GetInitSize() IFileSizeLiteralContext + + // GetUndoSize returns the undoSize rule contexts. + GetUndoSize() IFileSizeLiteralContext + + // GetRedoSize returns the redoSize rule contexts. + GetRedoSize() IFileSizeLiteralContext + + // SetInitSize sets the initSize rule contexts. + SetInitSize(IFileSizeLiteralContext) + + // SetUndoSize sets the undoSize rule contexts. + SetUndoSize(IFileSizeLiteralContext) + + // SetRedoSize sets the redoSize rule contexts. + SetRedoSize(IFileSizeLiteralContext) + + // Getter signatures + CREATE() antlr.TerminalNode + LOGFILE() antlr.TerminalNode + GROUP() antlr.TerminalNode + AllUid() []IUidContext + Uid(i int) IUidContext + ADD() antlr.TerminalNode + UNDOFILE() antlr.TerminalNode + ENGINE() antlr.TerminalNode + EngineName() IEngineNameContext + AllSTRING_LITERAL() []antlr.TerminalNode + STRING_LITERAL(i int) antlr.TerminalNode + INITIAL_SIZE() antlr.TerminalNode + UNDO_BUFFER_SIZE() antlr.TerminalNode + REDO_BUFFER_SIZE() antlr.TerminalNode + NODEGROUP() antlr.TerminalNode + WAIT() antlr.TerminalNode + COMMENT() antlr.TerminalNode + AllEQUAL_SYMBOL() []antlr.TerminalNode + EQUAL_SYMBOL(i int) antlr.TerminalNode + AllFileSizeLiteral() []IFileSizeLiteralContext + FileSizeLiteral(i int) IFileSizeLiteralContext + + // IsCreateLogfileGroupContext differentiates from other interfaces. + IsCreateLogfileGroupContext() +} + +type CreateLogfileGroupContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + undoFile antlr.Token + initSize IFileSizeLiteralContext + undoSize IFileSizeLiteralContext + redoSize IFileSizeLiteralContext + comment antlr.Token +} + +func NewEmptyCreateLogfileGroupContext() *CreateLogfileGroupContext { + var p = new(CreateLogfileGroupContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_createLogfileGroup + return p +} + +func InitEmptyCreateLogfileGroupContext(p *CreateLogfileGroupContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_createLogfileGroup +} + +func (*CreateLogfileGroupContext) IsCreateLogfileGroupContext() {} + +func NewCreateLogfileGroupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateLogfileGroupContext { + var p = new(CreateLogfileGroupContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_createLogfileGroup + + return p +} + +func (s *CreateLogfileGroupContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateLogfileGroupContext) GetUndoFile() antlr.Token { return s.undoFile } + +func (s *CreateLogfileGroupContext) GetComment() antlr.Token { return s.comment } + +func (s *CreateLogfileGroupContext) SetUndoFile(v antlr.Token) { s.undoFile = v } + +func (s *CreateLogfileGroupContext) SetComment(v antlr.Token) { s.comment = v } + +func (s *CreateLogfileGroupContext) GetInitSize() IFileSizeLiteralContext { return s.initSize } + +func (s *CreateLogfileGroupContext) GetUndoSize() IFileSizeLiteralContext { return s.undoSize } + +func (s *CreateLogfileGroupContext) GetRedoSize() IFileSizeLiteralContext { return s.redoSize } + +func (s *CreateLogfileGroupContext) SetInitSize(v IFileSizeLiteralContext) { s.initSize = v } + +func (s *CreateLogfileGroupContext) SetUndoSize(v IFileSizeLiteralContext) { s.undoSize = v } + +func (s *CreateLogfileGroupContext) SetRedoSize(v IFileSizeLiteralContext) { s.redoSize = v } + +func (s *CreateLogfileGroupContext) CREATE() antlr.TerminalNode { + return s.GetToken(MySqlParserCREATE, 0) +} + +func (s *CreateLogfileGroupContext) LOGFILE() antlr.TerminalNode { + return s.GetToken(MySqlParserLOGFILE, 0) +} + +func (s *CreateLogfileGroupContext) GROUP() antlr.TerminalNode { + return s.GetToken(MySqlParserGROUP, 0) +} + +func (s *CreateLogfileGroupContext) AllUid() []IUidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUidContext); ok { + len++ + } + } + + tst := make([]IUidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUidContext); ok { + tst[i] = t.(IUidContext) + i++ + } + } + + return tst +} + +func (s *CreateLogfileGroupContext) Uid(i int) IUidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *CreateLogfileGroupContext) ADD() antlr.TerminalNode { + return s.GetToken(MySqlParserADD, 0) +} + +func (s *CreateLogfileGroupContext) UNDOFILE() antlr.TerminalNode { + return s.GetToken(MySqlParserUNDOFILE, 0) +} + +func (s *CreateLogfileGroupContext) ENGINE() antlr.TerminalNode { + return s.GetToken(MySqlParserENGINE, 0) +} + +func (s *CreateLogfileGroupContext) EngineName() IEngineNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEngineNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEngineNameContext) +} + +func (s *CreateLogfileGroupContext) AllSTRING_LITERAL() []antlr.TerminalNode { + return s.GetTokens(MySqlParserSTRING_LITERAL) +} + +func (s *CreateLogfileGroupContext) STRING_LITERAL(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, i) +} + +func (s *CreateLogfileGroupContext) INITIAL_SIZE() antlr.TerminalNode { + return s.GetToken(MySqlParserINITIAL_SIZE, 0) +} + +func (s *CreateLogfileGroupContext) UNDO_BUFFER_SIZE() antlr.TerminalNode { + return s.GetToken(MySqlParserUNDO_BUFFER_SIZE, 0) +} + +func (s *CreateLogfileGroupContext) REDO_BUFFER_SIZE() antlr.TerminalNode { + return s.GetToken(MySqlParserREDO_BUFFER_SIZE, 0) +} + +func (s *CreateLogfileGroupContext) NODEGROUP() antlr.TerminalNode { + return s.GetToken(MySqlParserNODEGROUP, 0) +} + +func (s *CreateLogfileGroupContext) WAIT() antlr.TerminalNode { + return s.GetToken(MySqlParserWAIT, 0) +} + +func (s *CreateLogfileGroupContext) COMMENT() antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMENT, 0) +} + +func (s *CreateLogfileGroupContext) AllEQUAL_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(MySqlParserEQUAL_SYMBOL) +} + +func (s *CreateLogfileGroupContext) EQUAL_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, i) +} + +func (s *CreateLogfileGroupContext) AllFileSizeLiteral() []IFileSizeLiteralContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFileSizeLiteralContext); ok { + len++ + } + } + + tst := make([]IFileSizeLiteralContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFileSizeLiteralContext); ok { + tst[i] = t.(IFileSizeLiteralContext) + i++ + } + } + + return tst +} + +func (s *CreateLogfileGroupContext) FileSizeLiteral(i int) IFileSizeLiteralContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFileSizeLiteralContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFileSizeLiteralContext) +} + +func (s *CreateLogfileGroupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateLogfileGroupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateLogfileGroupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCreateLogfileGroup(s) + } +} + +func (s *CreateLogfileGroupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCreateLogfileGroup(s) + } +} + +func (p *MySqlParser) CreateLogfileGroup() (localctx ICreateLogfileGroupContext) { + localctx = NewCreateLogfileGroupContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 30, MySqlParserRULE_createLogfileGroup) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(984) + p.Match(MySqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(985) + p.Match(MySqlParserLOGFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(986) + p.Match(MySqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(987) + p.Uid() + } + { + p.SetState(988) + p.Match(MySqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(989) + p.Match(MySqlParserUNDOFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(990) + + var _m = p.Match(MySqlParserSTRING_LITERAL) + + localctx.(*CreateLogfileGroupContext).undoFile = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(996) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserINITIAL_SIZE { + { + p.SetState(991) + p.Match(MySqlParserINITIAL_SIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(993) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(992) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(995) + + var _x = p.FileSizeLiteral() + + localctx.(*CreateLogfileGroupContext).initSize = _x + } + + } + p.SetState(1003) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserUNDO_BUFFER_SIZE { + { + p.SetState(998) + p.Match(MySqlParserUNDO_BUFFER_SIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1000) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(999) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1002) + + var _x = p.FileSizeLiteral() + + localctx.(*CreateLogfileGroupContext).undoSize = _x + } + + } + p.SetState(1010) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserREDO_BUFFER_SIZE { + { + p.SetState(1005) + p.Match(MySqlParserREDO_BUFFER_SIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1007) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1006) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1009) + + var _x = p.FileSizeLiteral() + + localctx.(*CreateLogfileGroupContext).redoSize = _x + } + + } + p.SetState(1017) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserNODEGROUP { + { + p.SetState(1012) + p.Match(MySqlParserNODEGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1014) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1013) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1016) + p.Uid() + } + + } + p.SetState(1020) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserWAIT { + { + p.SetState(1019) + p.Match(MySqlParserWAIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(1027) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserCOMMENT { + { + p.SetState(1022) + p.Match(MySqlParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1024) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1023) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1026) + + var _m = p.Match(MySqlParserSTRING_LITERAL) + + localctx.(*CreateLogfileGroupContext).comment = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1029) + p.Match(MySqlParserENGINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1031) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1030) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1033) + p.EngineName() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreateProcedureContext is an interface to support dynamic dispatch. +type ICreateProcedureContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + PROCEDURE() antlr.TerminalNode + FullId() IFullIdContext + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + RoutineBody() IRoutineBodyContext + OwnerStatement() IOwnerStatementContext + AllProcedureParameter() []IProcedureParameterContext + ProcedureParameter(i int) IProcedureParameterContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllRoutineOption() []IRoutineOptionContext + RoutineOption(i int) IRoutineOptionContext + + // IsCreateProcedureContext differentiates from other interfaces. + IsCreateProcedureContext() +} + +type CreateProcedureContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreateProcedureContext() *CreateProcedureContext { + var p = new(CreateProcedureContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_createProcedure + return p +} + +func InitEmptyCreateProcedureContext(p *CreateProcedureContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_createProcedure +} + +func (*CreateProcedureContext) IsCreateProcedureContext() {} + +func NewCreateProcedureContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateProcedureContext { + var p = new(CreateProcedureContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_createProcedure + + return p +} + +func (s *CreateProcedureContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateProcedureContext) CREATE() antlr.TerminalNode { + return s.GetToken(MySqlParserCREATE, 0) +} + +func (s *CreateProcedureContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(MySqlParserPROCEDURE, 0) +} + +func (s *CreateProcedureContext) FullId() IFullIdContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFullIdContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFullIdContext) +} + +func (s *CreateProcedureContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *CreateProcedureContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *CreateProcedureContext) RoutineBody() IRoutineBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRoutineBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRoutineBodyContext) +} + +func (s *CreateProcedureContext) OwnerStatement() IOwnerStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOwnerStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOwnerStatementContext) +} + +func (s *CreateProcedureContext) AllProcedureParameter() []IProcedureParameterContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IProcedureParameterContext); ok { + len++ + } + } + + tst := make([]IProcedureParameterContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IProcedureParameterContext); ok { + tst[i] = t.(IProcedureParameterContext) + i++ + } + } + + return tst +} + +func (s *CreateProcedureContext) ProcedureParameter(i int) IProcedureParameterContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProcedureParameterContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IProcedureParameterContext) +} + +func (s *CreateProcedureContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *CreateProcedureContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *CreateProcedureContext) AllRoutineOption() []IRoutineOptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRoutineOptionContext); ok { + len++ + } + } + + tst := make([]IRoutineOptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRoutineOptionContext); ok { + tst[i] = t.(IRoutineOptionContext) + i++ + } + } + + return tst +} + +func (s *CreateProcedureContext) RoutineOption(i int) IRoutineOptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRoutineOptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRoutineOptionContext) +} + +func (s *CreateProcedureContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateProcedureContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateProcedureContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCreateProcedure(s) + } +} + +func (s *CreateProcedureContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCreateProcedure(s) + } +} + +func (p *MySqlParser) CreateProcedure() (localctx ICreateProcedureContext) { + localctx = NewCreateProcedureContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 32, MySqlParserRULE_createProcedure) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1035) + p.Match(MySqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1037) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserDEFINER { + { + p.SetState(1036) + p.OwnerStatement() + } + + } + { + p.SetState(1039) + p.Match(MySqlParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1040) + p.FullId() + } + { + p.SetState(1041) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1043) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&151169654698547409) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-34354363873) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-2199023255553) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-5764611921080745985) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-8796126576641) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-32651097298436097) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-18014398517872129) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-137438953601) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-44473063500156929) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-129) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-12289) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&-1) != 0) || ((int64((_la-1128)) & ^0x3f) == 0 && ((int64(1)<<(_la-1128))&8627683329) != 0) { + { + p.SetState(1042) + p.ProcedureParameter() + } + + } + p.SetState(1049) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(1045) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1046) + p.ProcedureParameter() + } + + p.SetState(1051) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1052) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1056) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 49, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(1053) + p.RoutineOption() + } + + } + p.SetState(1058) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 49, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + { + p.SetState(1059) + p.RoutineBody() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreateFunctionContext is an interface to support dynamic dispatch. +type ICreateFunctionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + FullId() IFullIdContext + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + RETURNS() antlr.TerminalNode + DataType() IDataTypeContext + RoutineBody() IRoutineBodyContext + ReturnStatement() IReturnStatementContext + OwnerStatement() IOwnerStatementContext + AGGREGATE() antlr.TerminalNode + IfNotExists() IIfNotExistsContext + AllFunctionParameter() []IFunctionParameterContext + FunctionParameter(i int) IFunctionParameterContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllRoutineOption() []IRoutineOptionContext + RoutineOption(i int) IRoutineOptionContext + + // IsCreateFunctionContext differentiates from other interfaces. + IsCreateFunctionContext() +} + +type CreateFunctionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreateFunctionContext() *CreateFunctionContext { + var p = new(CreateFunctionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_createFunction + return p +} + +func InitEmptyCreateFunctionContext(p *CreateFunctionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_createFunction +} + +func (*CreateFunctionContext) IsCreateFunctionContext() {} + +func NewCreateFunctionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateFunctionContext { + var p = new(CreateFunctionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_createFunction + + return p +} + +func (s *CreateFunctionContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateFunctionContext) CREATE() antlr.TerminalNode { + return s.GetToken(MySqlParserCREATE, 0) +} + +func (s *CreateFunctionContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(MySqlParserFUNCTION, 0) +} + +func (s *CreateFunctionContext) FullId() IFullIdContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFullIdContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFullIdContext) +} + +func (s *CreateFunctionContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *CreateFunctionContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *CreateFunctionContext) RETURNS() antlr.TerminalNode { + return s.GetToken(MySqlParserRETURNS, 0) +} + +func (s *CreateFunctionContext) DataType() IDataTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDataTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDataTypeContext) +} + +func (s *CreateFunctionContext) RoutineBody() IRoutineBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRoutineBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRoutineBodyContext) +} + +func (s *CreateFunctionContext) ReturnStatement() IReturnStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReturnStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReturnStatementContext) +} + +func (s *CreateFunctionContext) OwnerStatement() IOwnerStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOwnerStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOwnerStatementContext) +} + +func (s *CreateFunctionContext) AGGREGATE() antlr.TerminalNode { + return s.GetToken(MySqlParserAGGREGATE, 0) +} + +func (s *CreateFunctionContext) IfNotExists() IIfNotExistsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfNotExistsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfNotExistsContext) +} + +func (s *CreateFunctionContext) AllFunctionParameter() []IFunctionParameterContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFunctionParameterContext); ok { + len++ + } + } + + tst := make([]IFunctionParameterContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFunctionParameterContext); ok { + tst[i] = t.(IFunctionParameterContext) + i++ + } + } + + return tst +} + +func (s *CreateFunctionContext) FunctionParameter(i int) IFunctionParameterContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionParameterContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFunctionParameterContext) +} + +func (s *CreateFunctionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *CreateFunctionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *CreateFunctionContext) AllRoutineOption() []IRoutineOptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRoutineOptionContext); ok { + len++ + } + } + + tst := make([]IRoutineOptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRoutineOptionContext); ok { + tst[i] = t.(IRoutineOptionContext) + i++ + } + } + + return tst +} + +func (s *CreateFunctionContext) RoutineOption(i int) IRoutineOptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRoutineOptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRoutineOptionContext) +} + +func (s *CreateFunctionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateFunctionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateFunctionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCreateFunction(s) + } +} + +func (s *CreateFunctionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCreateFunction(s) + } +} + +func (p *MySqlParser) CreateFunction() (localctx ICreateFunctionContext) { + localctx = NewCreateFunctionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 34, MySqlParserRULE_createFunction) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1061) + p.Match(MySqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1063) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserDEFINER { + { + p.SetState(1062) + p.OwnerStatement() + } + + } + p.SetState(1066) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserAGGREGATE { + { + p.SetState(1065) + p.Match(MySqlParserAGGREGATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1068) + p.Match(MySqlParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1070) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 52, p.GetParserRuleContext()) == 1 { + { + p.SetState(1069) + p.IfNotExists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(1072) + p.FullId() + } + { + p.SetState(1073) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1075) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-34354363873) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-2199023255553) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-5764611921080745985) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-8796126576641) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-32651097298436097) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-18014398517872129) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-137438953601) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-44473063500156929) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-129) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-12289) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&-1) != 0) || ((int64((_la-1128)) & ^0x3f) == 0 && ((int64(1)<<(_la-1128))&8627683329) != 0) { + { + p.SetState(1074) + p.FunctionParameter() + } + + } + p.SetState(1081) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(1077) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1078) + p.FunctionParameter() + } + + p.SetState(1083) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1084) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1085) + p.Match(MySqlParserRETURNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1086) + p.DataType() + } + p.SetState(1090) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 55, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(1087) + p.RoutineOption() + } + + } + p.SetState(1092) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 55, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(1095) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserALTER, MySqlParserANALYZE, MySqlParserARRAY, MySqlParserATTRIBUTE, MySqlParserBUCKETS, MySqlParserCALL, MySqlParserCHANGE, MySqlParserCHECK, MySqlParserCONDITION, MySqlParserCREATE, MySqlParserCURRENT, MySqlParserCURRENT_USER, MySqlParserDATABASE, MySqlParserDEFAULT, MySqlParserDELETE, MySqlParserDESC, MySqlParserDESCRIBE, MySqlParserDIAGNOSTICS, MySqlParserDROP, MySqlParserEMPTY, MySqlParserENFORCED, MySqlParserEXCEPT, MySqlParserEXPLAIN, MySqlParserGET, MySqlParserGRANT, MySqlParserGROUP, MySqlParserIF, MySqlParserIGNORED, MySqlParserINSERT, MySqlParserKILL, MySqlParserLATERAL, MySqlParserLEFT, MySqlParserLOAD, MySqlParserLOCK, MySqlParserNUMBER, MySqlParserOPTIMIZE, MySqlParserOPTIONAL, MySqlParserORDER, MySqlParserPRIMARY, MySqlParserPURGE, MySqlParserRELEASE, MySqlParserRENAME, MySqlParserREPEAT, MySqlParserREPLACE, MySqlParserRESIGNAL, MySqlParserREVOKE, MySqlParserRIGHT, MySqlParserSCHEMA, MySqlParserSELECT, MySqlParserSET, MySqlParserSHOW, MySqlParserSIGNAL, MySqlParserSKIP_QUERY_REWRITE, MySqlParserSTACKED, MySqlParserSTATEMENT, MySqlParserTABLE, MySqlParserUNLOCK, MySqlParserUPDATE, MySqlParserUSE, MySqlParserVALUES, MySqlParserWITH, MySqlParserDATE, MySqlParserTIME, MySqlParserTIMESTAMP, MySqlParserDATETIME, MySqlParserYEAR, MySqlParserBINARY, MySqlParserTEXT, MySqlParserENUM, MySqlParserSERIAL, MySqlParserJSON_ARRAY, MySqlParserJSON_ARRAYAGG, MySqlParserJSON_ARRAY_APPEND, MySqlParserJSON_ARRAY_INSERT, MySqlParserJSON_CONTAINS, MySqlParserJSON_CONTAINS_PATH, MySqlParserJSON_DEPTH, MySqlParserJSON_EXTRACT, MySqlParserJSON_INSERT, MySqlParserJSON_KEYS, MySqlParserJSON_LENGTH, MySqlParserJSON_MERGE, MySqlParserJSON_MERGE_PATCH, MySqlParserJSON_MERGE_PRESERVE, MySqlParserJSON_OBJECT, MySqlParserJSON_OBJECTAGG, MySqlParserJSON_OVERLAPS, MySqlParserJSON_PRETTY, MySqlParserJSON_QUOTE, MySqlParserJSON_REMOVE, MySqlParserJSON_REPLACE, MySqlParserJSON_SCHEMA_VALID, MySqlParserJSON_SCHEMA_VALIDATION_REPORT, MySqlParserJSON_SEARCH, MySqlParserJSON_SET, MySqlParserJSON_STORAGE_FREE, MySqlParserJSON_STORAGE_SIZE, MySqlParserJSON_TABLE, MySqlParserJSON_TYPE, MySqlParserJSON_UNQUOTE, MySqlParserJSON_VALID, MySqlParserJSON_VALUE, MySqlParserNESTED, MySqlParserORDINALITY, MySqlParserPATH, MySqlParserAVG, MySqlParserBIT_AND, MySqlParserBIT_OR, MySqlParserBIT_XOR, MySqlParserCOUNT, MySqlParserCUME_DIST, MySqlParserDENSE_RANK, MySqlParserFIRST_VALUE, MySqlParserGROUP_CONCAT, MySqlParserLAG, MySqlParserLAST_VALUE, MySqlParserLEAD, MySqlParserMAX, MySqlParserMIN, MySqlParserNTILE, MySqlParserNTH_VALUE, MySqlParserPERCENT_RANK, MySqlParserRANK, MySqlParserROW_NUMBER, MySqlParserSTD, MySqlParserSTDDEV, MySqlParserSTDDEV_POP, MySqlParserSTDDEV_SAMP, MySqlParserSUM, MySqlParserVAR_POP, MySqlParserVAR_SAMP, MySqlParserVARIANCE, MySqlParserCURRENT_DATE, MySqlParserCURRENT_TIME, MySqlParserCURRENT_TIMESTAMP, MySqlParserLOCALTIME, MySqlParserCURDATE, MySqlParserCURTIME, MySqlParserDATE_ADD, MySqlParserDATE_SUB, MySqlParserLOCALTIMESTAMP, MySqlParserNOW, MySqlParserPOSITION, MySqlParserSUBSTR, MySqlParserSUBSTRING, MySqlParserSYSDATE, MySqlParserTRIM, MySqlParserUTC_DATE, MySqlParserUTC_TIME, MySqlParserUTC_TIMESTAMP, MySqlParserACCOUNT, MySqlParserACTION, MySqlParserAFTER, MySqlParserAGGREGATE, MySqlParserALGORITHM, MySqlParserANY, MySqlParserAT, MySqlParserAUTHORS, MySqlParserAUTOCOMMIT, MySqlParserAUTOEXTEND_SIZE, MySqlParserAUTO_INCREMENT, MySqlParserAVG_ROW_LENGTH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserBIT, MySqlParserBLOCK, MySqlParserBOOL, MySqlParserBOOLEAN, MySqlParserBTREE, MySqlParserCACHE, MySqlParserCASCADED, MySqlParserCHAIN, MySqlParserCHANGED, MySqlParserCHANNEL, MySqlParserCHECKSUM, MySqlParserPAGE_CHECKSUM, MySqlParserCIPHER, MySqlParserCLASS_ORIGIN, MySqlParserCLIENT, MySqlParserCLOSE, MySqlParserCLUSTERING, MySqlParserCOALESCE, MySqlParserCODE, MySqlParserCOLUMNS, MySqlParserCOLUMN_FORMAT, MySqlParserCOLUMN_NAME, MySqlParserCOMMENT, MySqlParserCOMMIT, MySqlParserCOMPACT, MySqlParserCOMPLETION, MySqlParserCOMPRESSED, MySqlParserCOMPRESSION, MySqlParserCONCURRENT, MySqlParserCONNECT, MySqlParserCONNECTION, MySqlParserCONSISTENT, MySqlParserCONSTRAINT_CATALOG, MySqlParserCONSTRAINT_SCHEMA, MySqlParserCONSTRAINT_NAME, MySqlParserCONTAINS, MySqlParserCONTEXT, MySqlParserCONTRIBUTORS, MySqlParserCOPY, MySqlParserCPU, MySqlParserCURSOR_NAME, MySqlParserDATA, MySqlParserDATAFILE, MySqlParserDEALLOCATE, MySqlParserDEFAULT_AUTH, MySqlParserDEFINER, MySqlParserDELAY_KEY_WRITE, MySqlParserDES_KEY_FILE, MySqlParserDIRECTORY, MySqlParserDISABLE, MySqlParserDISCARD, MySqlParserDISK, MySqlParserDO, MySqlParserDUMPFILE, MySqlParserDUPLICATE, MySqlParserDYNAMIC, MySqlParserENABLE, MySqlParserENCRYPTION, MySqlParserEND, MySqlParserENDS, MySqlParserENGINE, MySqlParserENGINES, MySqlParserERROR, MySqlParserERRORS, MySqlParserESCAPE, MySqlParserEVEN, MySqlParserEVENT, MySqlParserEVENTS, MySqlParserEVERY, MySqlParserEXCHANGE, MySqlParserEXCLUSIVE, MySqlParserEXPIRE, MySqlParserEXPORT, MySqlParserEXTENDED, MySqlParserEXTENT_SIZE, MySqlParserFAILED_LOGIN_ATTEMPTS, MySqlParserFAST, MySqlParserFAULTS, MySqlParserFIELDS, MySqlParserFILE_BLOCK_SIZE, MySqlParserFILTER, MySqlParserFIRST, MySqlParserFIXED, MySqlParserFLUSH, MySqlParserFOLLOWS, MySqlParserFOUND, MySqlParserFULL, MySqlParserFUNCTION, MySqlParserGENERAL, MySqlParserGLOBAL, MySqlParserGRANTS, MySqlParserGROUP_REPLICATION, MySqlParserHANDLER, MySqlParserHASH, MySqlParserHELP, MySqlParserHISTORY, MySqlParserHOST, MySqlParserHOSTS, MySqlParserIDENTIFIED, MySqlParserIGNORE_SERVER_IDS, MySqlParserIMPORT, MySqlParserINDEXES, MySqlParserINITIAL_SIZE, MySqlParserINPLACE, MySqlParserINSERT_METHOD, MySqlParserINSTALL, MySqlParserINSTANCE, MySqlParserINSTANT, MySqlParserINVISIBLE, MySqlParserINVOKER, MySqlParserIO, MySqlParserIO_THREAD, MySqlParserIPC, MySqlParserISOLATION, MySqlParserISSUER, MySqlParserJSON, MySqlParserKEY_BLOCK_SIZE, MySqlParserLANGUAGE, MySqlParserLAST, MySqlParserLEAVES, MySqlParserLESS, MySqlParserLEVEL, MySqlParserLIST, MySqlParserLOCAL, MySqlParserLOGFILE, MySqlParserLOGS, MySqlParserMASTER, MySqlParserMASTER_AUTO_POSITION, MySqlParserMASTER_CONNECT_RETRY, MySqlParserMASTER_DELAY, MySqlParserMASTER_HEARTBEAT_PERIOD, MySqlParserMASTER_HOST, MySqlParserMASTER_LOG_FILE, MySqlParserMASTER_LOG_POS, MySqlParserMASTER_PASSWORD, MySqlParserMASTER_PORT, MySqlParserMASTER_RETRY_COUNT, MySqlParserMASTER_SSL, MySqlParserMASTER_SSL_CA, MySqlParserMASTER_SSL_CAPATH, MySqlParserMASTER_SSL_CERT, MySqlParserMASTER_SSL_CIPHER, MySqlParserMASTER_SSL_CRL, MySqlParserMASTER_SSL_CRLPATH, MySqlParserMASTER_SSL_KEY, MySqlParserMASTER_TLS_VERSION, MySqlParserMASTER_USER, MySqlParserMAX_CONNECTIONS_PER_HOUR, MySqlParserMAX_QUERIES_PER_HOUR, MySqlParserMAX_ROWS, MySqlParserMAX_SIZE, MySqlParserMAX_UPDATES_PER_HOUR, MySqlParserMAX_USER_CONNECTIONS, MySqlParserMEDIUM, MySqlParserMEMBER, MySqlParserMERGE, MySqlParserMESSAGE_TEXT, MySqlParserMID, MySqlParserMIGRATE, MySqlParserMIN_ROWS, MySqlParserMODE, MySqlParserMODIFY, MySqlParserMUTEX, MySqlParserMYSQL, MySqlParserMYSQL_ERRNO, MySqlParserNAME, MySqlParserNAMES, MySqlParserNCHAR, MySqlParserNEVER, MySqlParserNEXT, MySqlParserNO, MySqlParserNOCOPY, MySqlParserNOWAIT, MySqlParserNODEGROUP, MySqlParserNONE, MySqlParserODBC, MySqlParserOFFLINE, MySqlParserOFFSET, MySqlParserOF, MySqlParserOJ, MySqlParserOLD_PASSWORD, MySqlParserONE, MySqlParserONLINE, MySqlParserONLY, MySqlParserOPEN, MySqlParserOPTIMIZER_COSTS, MySqlParserOPTIONS, MySqlParserOWNER, MySqlParserPACK_KEYS, MySqlParserPAGE, MySqlParserPARSER, MySqlParserPARTIAL, MySqlParserPARTITIONING, MySqlParserPARTITIONS, MySqlParserPASSWORD, MySqlParserPASSWORD_LOCK_TIME, MySqlParserPHASE, MySqlParserPLUGIN, MySqlParserPLUGIN_DIR, MySqlParserPLUGINS, MySqlParserPORT, MySqlParserPRECEDES, MySqlParserPREPARE, MySqlParserPRESERVE, MySqlParserPREV, MySqlParserPROCESSLIST, MySqlParserPROFILE, MySqlParserPROFILES, MySqlParserPROXY, MySqlParserQUERY, MySqlParserQUICK, MySqlParserREBUILD, MySqlParserRECOVER, MySqlParserRECURSIVE, MySqlParserREDO_BUFFER_SIZE, MySqlParserREDUNDANT, MySqlParserRELAY, MySqlParserRELAY_LOG_FILE, MySqlParserRELAY_LOG_POS, MySqlParserRELAYLOG, MySqlParserREMOVE, MySqlParserREORGANIZE, MySqlParserREPAIR, MySqlParserREPLICATE_DO_DB, MySqlParserREPLICATE_DO_TABLE, MySqlParserREPLICATE_IGNORE_DB, MySqlParserREPLICATE_IGNORE_TABLE, MySqlParserREPLICATE_REWRITE_DB, MySqlParserREPLICATE_WILD_DO_TABLE, MySqlParserREPLICATE_WILD_IGNORE_TABLE, MySqlParserREPLICATION, MySqlParserRESET, MySqlParserRESUME, MySqlParserRETURNED_SQLSTATE, MySqlParserRETURNING, MySqlParserRETURNS, MySqlParserREUSE, MySqlParserROLE, MySqlParserROLLBACK, MySqlParserROLLUP, MySqlParserROTATE, MySqlParserROW, MySqlParserROWS, MySqlParserROW_FORMAT, MySqlParserRTREE, MySqlParserSAVEPOINT, MySqlParserSCHEDULE, MySqlParserSECURITY, MySqlParserSERVER, MySqlParserSESSION, MySqlParserSHARE, MySqlParserSHARED, MySqlParserSIGNED, MySqlParserSIMPLE, MySqlParserSLAVE, MySqlParserSLOW, MySqlParserSNAPSHOT, MySqlParserSOCKET, MySqlParserSOME, MySqlParserSONAME, MySqlParserSOUNDS, MySqlParserSOURCE, MySqlParserSQL_AFTER_GTIDS, MySqlParserSQL_AFTER_MTS_GAPS, MySqlParserSQL_BEFORE_GTIDS, MySqlParserSQL_BUFFER_RESULT, MySqlParserSQL_CACHE, MySqlParserSQL_NO_CACHE, MySqlParserSQL_THREAD, MySqlParserSTART, MySqlParserSTARTS, MySqlParserSTATS_AUTO_RECALC, MySqlParserSTATS_PERSISTENT, MySqlParserSTATS_SAMPLE_PAGES, MySqlParserSTATUS, MySqlParserSTOP, MySqlParserSTORAGE, MySqlParserSTRING, MySqlParserSUBCLASS_ORIGIN, MySqlParserSUBJECT, MySqlParserSUBPARTITION, MySqlParserSUBPARTITIONS, MySqlParserSUSPEND, MySqlParserSWAPS, MySqlParserSWITCHES, MySqlParserTABLE_NAME, MySqlParserTABLESPACE, MySqlParserTABLE_TYPE, MySqlParserTEMPORARY, MySqlParserTEMPTABLE, MySqlParserTHAN, MySqlParserTRADITIONAL, MySqlParserTRANSACTION, MySqlParserTRANSACTIONAL, MySqlParserTRIGGERS, MySqlParserTRUNCATE, MySqlParserUNBOUNDED, MySqlParserUNDEFINED, MySqlParserUNDOFILE, MySqlParserUNDO_BUFFER_SIZE, MySqlParserUNINSTALL, MySqlParserUNKNOWN, MySqlParserUNTIL, MySqlParserUPGRADE, MySqlParserUSER, MySqlParserUSE_FRM, MySqlParserUSER_RESOURCES, MySqlParserVALIDATION, MySqlParserVALUE, MySqlParserVARIABLES, MySqlParserVIEW, MySqlParserVIRTUAL, MySqlParserVISIBLE, MySqlParserWAIT, MySqlParserWARNINGS, MySqlParserWITHOUT, MySqlParserWORK, MySqlParserWRAPPER, MySqlParserX509, MySqlParserXA, MySqlParserXML, MySqlParserYES, MySqlParserEUR, MySqlParserUSA, MySqlParserJIS, MySqlParserISO, MySqlParserINTERNAL, MySqlParserQUARTER, MySqlParserMONTH, MySqlParserDAY, MySqlParserHOUR, MySqlParserMINUTE, MySqlParserWEEK, MySqlParserSECOND, MySqlParserMICROSECOND, MySqlParserADMIN, MySqlParserAUDIT_ABORT_EXEMPT, MySqlParserAUDIT_ADMIN, MySqlParserAUTHENTICATION_POLICY_ADMIN, MySqlParserBACKUP_ADMIN, MySqlParserBINLOG_ADMIN, MySqlParserBINLOG_ENCRYPTION_ADMIN, MySqlParserCLONE_ADMIN, MySqlParserCONNECTION_ADMIN, MySqlParserENCRYPTION_KEY_ADMIN, MySqlParserEXECUTE, MySqlParserFILE, MySqlParserFIREWALL_ADMIN, MySqlParserFIREWALL_EXEMPT, MySqlParserFIREWALL_USER, MySqlParserGROUP_REPLICATION_ADMIN, MySqlParserINNODB_REDO_LOG_ARCHIVE, MySqlParserINVOKE, MySqlParserLAMBDA, MySqlParserNDB_STORED_USER, MySqlParserPASSWORDLESS_USER_ADMIN, MySqlParserPERSIST_RO_VARIABLES_ADMIN, MySqlParserPRIVILEGES, MySqlParserPROCESS, MySqlParserRELOAD, MySqlParserREPLICATION_APPLIER, MySqlParserREPLICATION_SLAVE_ADMIN, MySqlParserRESOURCE_GROUP_ADMIN, MySqlParserRESOURCE_GROUP_USER, MySqlParserROLE_ADMIN, MySqlParserROUTINE, MySqlParserS3, MySqlParserSESSION_VARIABLES_ADMIN, MySqlParserSET_USER_ID, MySqlParserSHOW_ROUTINE, MySqlParserSHUTDOWN, MySqlParserSUPER, MySqlParserSYSTEM_VARIABLES_ADMIN, MySqlParserTABLES, MySqlParserTABLE_ENCRYPTION_ADMIN, MySqlParserVERSION_TOKEN_ADMIN, MySqlParserXA_RECOVER_ADMIN, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserARCHIVE, MySqlParserBLACKHOLE, MySqlParserCSV, MySqlParserFEDERATED, MySqlParserINNODB, MySqlParserMEMORY, MySqlParserMRG_MYISAM, MySqlParserMYISAM, MySqlParserNDB, MySqlParserNDBCLUSTER, MySqlParserPERFORMANCE_SCHEMA, MySqlParserTOKUDB, MySqlParserREPEATABLE, MySqlParserCOMMITTED, MySqlParserUNCOMMITTED, MySqlParserSERIALIZABLE, MySqlParserGEOMETRYCOLLECTION, MySqlParserLINESTRING, MySqlParserMULTILINESTRING, MySqlParserMULTIPOINT, MySqlParserMULTIPOLYGON, MySqlParserPOINT, MySqlParserPOLYGON, MySqlParserABS, MySqlParserACOS, MySqlParserADDDATE, MySqlParserADDTIME, MySqlParserAES_DECRYPT, MySqlParserAES_ENCRYPT, MySqlParserAREA, MySqlParserASBINARY, MySqlParserASIN, MySqlParserASTEXT, MySqlParserASWKB, MySqlParserASWKT, MySqlParserASYMMETRIC_DECRYPT, MySqlParserASYMMETRIC_DERIVE, MySqlParserASYMMETRIC_ENCRYPT, MySqlParserASYMMETRIC_SIGN, MySqlParserASYMMETRIC_VERIFY, MySqlParserATAN, MySqlParserATAN2, MySqlParserBENCHMARK, MySqlParserBIN, MySqlParserBIT_COUNT, MySqlParserBIT_LENGTH, MySqlParserBUFFER, MySqlParserCATALOG_NAME, MySqlParserCEIL, MySqlParserCEILING, MySqlParserCENTROID, MySqlParserCHARACTER_LENGTH, MySqlParserCHARSET, MySqlParserCHAR_LENGTH, MySqlParserCOERCIBILITY, MySqlParserCOLLATION, MySqlParserCOMPRESS, MySqlParserCONCAT, MySqlParserCONCAT_WS, MySqlParserCONNECTION_ID, MySqlParserCONV, MySqlParserCONVERT_TZ, MySqlParserCOS, MySqlParserCOT, MySqlParserCRC32, MySqlParserCREATE_ASYMMETRIC_PRIV_KEY, MySqlParserCREATE_ASYMMETRIC_PUB_KEY, MySqlParserCREATE_DH_PARAMETERS, MySqlParserCREATE_DIGEST, MySqlParserCROSSES, MySqlParserDATEDIFF, MySqlParserDATE_FORMAT, MySqlParserDAYNAME, MySqlParserDAYOFMONTH, MySqlParserDAYOFWEEK, MySqlParserDAYOFYEAR, MySqlParserDECODE, MySqlParserDEGREES, MySqlParserDES_DECRYPT, MySqlParserDES_ENCRYPT, MySqlParserDIMENSION, MySqlParserDISJOINT, MySqlParserDISTANCE, MySqlParserELT, MySqlParserENCODE, MySqlParserENCRYPT, MySqlParserENDPOINT, MySqlParserENGINE_ATTRIBUTE, MySqlParserENVELOPE, MySqlParserEQUALS, MySqlParserEXP, MySqlParserEXPORT_SET, MySqlParserEXTERIORRING, MySqlParserEXTRACTVALUE, MySqlParserFIELD, MySqlParserFIND_IN_SET, MySqlParserFLOOR, MySqlParserFORMAT, MySqlParserFOUND_ROWS, MySqlParserFROM_BASE64, MySqlParserFROM_DAYS, MySqlParserFROM_UNIXTIME, MySqlParserGEOMCOLLFROMTEXT, MySqlParserGEOMCOLLFROMWKB, MySqlParserGEOMETRYCOLLECTIONFROMTEXT, MySqlParserGEOMETRYCOLLECTIONFROMWKB, MySqlParserGEOMETRYFROMTEXT, MySqlParserGEOMETRYFROMWKB, MySqlParserGEOMETRYN, MySqlParserGEOMETRYTYPE, MySqlParserGEOMFROMTEXT, MySqlParserGEOMFROMWKB, MySqlParserGET_FORMAT, MySqlParserGET_LOCK, MySqlParserGLENGTH, MySqlParserGREATEST, MySqlParserGTID_SUBSET, MySqlParserGTID_SUBTRACT, MySqlParserHEX, MySqlParserIFNULL, MySqlParserINET6_ATON, MySqlParserINET6_NTOA, MySqlParserINET_ATON, MySqlParserINET_NTOA, MySqlParserINSTR, MySqlParserINTERIORRINGN, MySqlParserINTERSECTS, MySqlParserISCLOSED, MySqlParserISEMPTY, MySqlParserISNULL, MySqlParserISSIMPLE, MySqlParserIS_FREE_LOCK, MySqlParserIS_IPV4, MySqlParserIS_IPV4_COMPAT, MySqlParserIS_IPV4_MAPPED, MySqlParserIS_IPV6, MySqlParserIS_USED_LOCK, MySqlParserLAST_INSERT_ID, MySqlParserLCASE, MySqlParserLEAST, MySqlParserLENGTH, MySqlParserLINEFROMTEXT, MySqlParserLINEFROMWKB, MySqlParserLINESTRINGFROMTEXT, MySqlParserLINESTRINGFROMWKB, MySqlParserLN, MySqlParserLOAD_FILE, MySqlParserLOCATE, MySqlParserLOG, MySqlParserLOG10, MySqlParserLOG2, MySqlParserLOWER, MySqlParserLPAD, MySqlParserLTRIM, MySqlParserMAKEDATE, MySqlParserMAKETIME, MySqlParserMAKE_SET, MySqlParserMASTER_POS_WAIT, MySqlParserMBRCONTAINS, MySqlParserMBRDISJOINT, MySqlParserMBREQUAL, MySqlParserMBRINTERSECTS, MySqlParserMBROVERLAPS, MySqlParserMBRTOUCHES, MySqlParserMBRWITHIN, MySqlParserMD5, MySqlParserMLINEFROMTEXT, MySqlParserMLINEFROMWKB, MySqlParserMONTHNAME, MySqlParserMPOINTFROMTEXT, MySqlParserMPOINTFROMWKB, MySqlParserMPOLYFROMTEXT, MySqlParserMPOLYFROMWKB, MySqlParserMULTILINESTRINGFROMTEXT, MySqlParserMULTILINESTRINGFROMWKB, MySqlParserMULTIPOINTFROMTEXT, MySqlParserMULTIPOINTFROMWKB, MySqlParserMULTIPOLYGONFROMTEXT, MySqlParserMULTIPOLYGONFROMWKB, MySqlParserNAME_CONST, MySqlParserNULLIF, MySqlParserNUMGEOMETRIES, MySqlParserNUMINTERIORRINGS, MySqlParserNUMPOINTS, MySqlParserOCT, MySqlParserOCTET_LENGTH, MySqlParserORD, MySqlParserOVERLAPS, MySqlParserPERIOD_ADD, MySqlParserPERIOD_DIFF, MySqlParserPI, MySqlParserPOINTFROMTEXT, MySqlParserPOINTFROMWKB, MySqlParserPOINTN, MySqlParserPOLYFROMTEXT, MySqlParserPOLYFROMWKB, MySqlParserPOLYGONFROMTEXT, MySqlParserPOLYGONFROMWKB, MySqlParserPOW, MySqlParserPOWER, MySqlParserQUOTE, MySqlParserRADIANS, MySqlParserRAND, MySqlParserRANDOM, MySqlParserRANDOM_BYTES, MySqlParserRELEASE_LOCK, MySqlParserREVERSE, MySqlParserROUND, MySqlParserROW_COUNT, MySqlParserRPAD, MySqlParserRTRIM, MySqlParserSEC_TO_TIME, MySqlParserSECONDARY_ENGINE_ATTRIBUTE, MySqlParserSESSION_USER, MySqlParserSHA, MySqlParserSHA1, MySqlParserSHA2, MySqlParserSCHEMA_NAME, MySqlParserSIGN, MySqlParserSIN, MySqlParserSLEEP, MySqlParserSOUNDEX, MySqlParserSQL_THREAD_WAIT_AFTER_GTIDS, MySqlParserSQRT, MySqlParserSRID, MySqlParserSTARTPOINT, MySqlParserSTRCMP, MySqlParserSTR_TO_DATE, MySqlParserST_AREA, MySqlParserST_ASBINARY, MySqlParserST_ASTEXT, MySqlParserST_ASWKB, MySqlParserST_ASWKT, MySqlParserST_BUFFER, MySqlParserST_CENTROID, MySqlParserST_CONTAINS, MySqlParserST_CROSSES, MySqlParserST_DIFFERENCE, MySqlParserST_DIMENSION, MySqlParserST_DISJOINT, MySqlParserST_DISTANCE, MySqlParserST_ENDPOINT, MySqlParserST_ENVELOPE, MySqlParserST_EQUALS, MySqlParserST_EXTERIORRING, MySqlParserST_GEOMCOLLFROMTEXT, MySqlParserST_GEOMCOLLFROMTXT, MySqlParserST_GEOMCOLLFROMWKB, MySqlParserST_GEOMETRYCOLLECTIONFROMTEXT, MySqlParserST_GEOMETRYCOLLECTIONFROMWKB, MySqlParserST_GEOMETRYFROMTEXT, MySqlParserST_GEOMETRYFROMWKB, MySqlParserST_GEOMETRYN, MySqlParserST_GEOMETRYTYPE, MySqlParserST_GEOMFROMTEXT, MySqlParserST_GEOMFROMWKB, MySqlParserST_INTERIORRINGN, MySqlParserST_INTERSECTION, MySqlParserST_INTERSECTS, MySqlParserST_ISCLOSED, MySqlParserST_ISEMPTY, MySqlParserST_ISSIMPLE, MySqlParserST_LINEFROMTEXT, MySqlParserST_LINEFROMWKB, MySqlParserST_LINESTRINGFROMTEXT, MySqlParserST_LINESTRINGFROMWKB, MySqlParserST_NUMGEOMETRIES, MySqlParserST_NUMINTERIORRING, MySqlParserST_NUMINTERIORRINGS, MySqlParserST_NUMPOINTS, MySqlParserST_OVERLAPS, MySqlParserST_POINTFROMTEXT, MySqlParserST_POINTFROMWKB, MySqlParserST_POINTN, MySqlParserST_POLYFROMTEXT, MySqlParserST_POLYFROMWKB, MySqlParserST_POLYGONFROMTEXT, MySqlParserST_POLYGONFROMWKB, MySqlParserST_SRID, MySqlParserST_STARTPOINT, MySqlParserST_SYMDIFFERENCE, MySqlParserST_TOUCHES, MySqlParserST_UNION, MySqlParserST_WITHIN, MySqlParserST_X, MySqlParserST_Y, MySqlParserSTRING_TO_VECTOR, MySqlParserSUBDATE, MySqlParserSUBSTRING_INDEX, MySqlParserSUBTIME, MySqlParserSYSTEM_USER, MySqlParserTAN, MySqlParserTIMEDIFF, MySqlParserTIMESTAMPADD, MySqlParserTIMESTAMPDIFF, MySqlParserTIME_FORMAT, MySqlParserTIME_TO_SEC, MySqlParserTOUCHES, MySqlParserTO_BASE64, MySqlParserTO_DAYS, MySqlParserTO_SECONDS, MySqlParserTP_CONNECTION_ADMIN, MySqlParserUCASE, MySqlParserUNCOMPRESS, MySqlParserUNCOMPRESSED_LENGTH, MySqlParserUNHEX, MySqlParserUNIX_TIMESTAMP, MySqlParserUPDATEXML, MySqlParserUPPER, MySqlParserUUID, MySqlParserUUID_SHORT, MySqlParserVALIDATE_PASSWORD_STRENGTH, MySqlParserVECTOR_DIM, MySqlParserVECTOR_TO_STRING, MySqlParserVERSION, MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS, MySqlParserWEEKDAY, MySqlParserWEEKOFYEAR, MySqlParserWEIGHT_STRING, MySqlParserWITHIN, MySqlParserYEARWEEK, MySqlParserY_FUNCTION, MySqlParserX_FUNCTION, MySqlParserMOD, MySqlParserLR_BRACKET, MySqlParserCHARSET_REVERSE_QOUTE_STRING, MySqlParserSTRING_LITERAL, MySqlParserID: + { + p.SetState(1093) + p.RoutineBody() + } + + case MySqlParserRETURN: + { + p.SetState(1094) + p.ReturnStatement() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreateRoleContext is an interface to support dynamic dispatch. +type ICreateRoleContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + ROLE() antlr.TerminalNode + AllRoleName() []IRoleNameContext + RoleName(i int) IRoleNameContext + IfNotExists() IIfNotExistsContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsCreateRoleContext differentiates from other interfaces. + IsCreateRoleContext() +} + +type CreateRoleContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreateRoleContext() *CreateRoleContext { + var p = new(CreateRoleContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_createRole + return p +} + +func InitEmptyCreateRoleContext(p *CreateRoleContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_createRole +} + +func (*CreateRoleContext) IsCreateRoleContext() {} + +func NewCreateRoleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateRoleContext { + var p = new(CreateRoleContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_createRole + + return p +} + +func (s *CreateRoleContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateRoleContext) CREATE() antlr.TerminalNode { + return s.GetToken(MySqlParserCREATE, 0) +} + +func (s *CreateRoleContext) ROLE() antlr.TerminalNode { + return s.GetToken(MySqlParserROLE, 0) +} + +func (s *CreateRoleContext) AllRoleName() []IRoleNameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRoleNameContext); ok { + len++ + } + } + + tst := make([]IRoleNameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRoleNameContext); ok { + tst[i] = t.(IRoleNameContext) + i++ + } + } + + return tst +} + +func (s *CreateRoleContext) RoleName(i int) IRoleNameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRoleNameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRoleNameContext) +} + +func (s *CreateRoleContext) IfNotExists() IIfNotExistsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfNotExistsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfNotExistsContext) +} + +func (s *CreateRoleContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *CreateRoleContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *CreateRoleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateRoleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateRoleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCreateRole(s) + } +} + +func (s *CreateRoleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCreateRole(s) + } +} + +func (p *MySqlParser) CreateRole() (localctx ICreateRoleContext) { + localctx = NewCreateRoleContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 36, MySqlParserRULE_createRole) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1097) + p.Match(MySqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1098) + p.Match(MySqlParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1100) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 57, p.GetParserRuleContext()) == 1 { + { + p.SetState(1099) + p.IfNotExists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(1102) + p.RoleName() + } + p.SetState(1107) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(1103) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1104) + p.RoleName() + } + + p.SetState(1109) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreateServerContext is an interface to support dynamic dispatch. +type ICreateServerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetWrapperName returns the wrapperName token. + GetWrapperName() antlr.Token + + // SetWrapperName sets the wrapperName token. + SetWrapperName(antlr.Token) + + // Getter signatures + CREATE() antlr.TerminalNode + SERVER() antlr.TerminalNode + Uid() IUidContext + FOREIGN() antlr.TerminalNode + DATA() antlr.TerminalNode + WRAPPER() antlr.TerminalNode + OPTIONS() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + AllServerOption() []IServerOptionContext + ServerOption(i int) IServerOptionContext + RR_BRACKET() antlr.TerminalNode + MYSQL() antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsCreateServerContext differentiates from other interfaces. + IsCreateServerContext() +} + +type CreateServerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + wrapperName antlr.Token +} + +func NewEmptyCreateServerContext() *CreateServerContext { + var p = new(CreateServerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_createServer + return p +} + +func InitEmptyCreateServerContext(p *CreateServerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_createServer +} + +func (*CreateServerContext) IsCreateServerContext() {} + +func NewCreateServerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateServerContext { + var p = new(CreateServerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_createServer + + return p +} + +func (s *CreateServerContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateServerContext) GetWrapperName() antlr.Token { return s.wrapperName } + +func (s *CreateServerContext) SetWrapperName(v antlr.Token) { s.wrapperName = v } + +func (s *CreateServerContext) CREATE() antlr.TerminalNode { + return s.GetToken(MySqlParserCREATE, 0) +} + +func (s *CreateServerContext) SERVER() antlr.TerminalNode { + return s.GetToken(MySqlParserSERVER, 0) +} + +func (s *CreateServerContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *CreateServerContext) FOREIGN() antlr.TerminalNode { + return s.GetToken(MySqlParserFOREIGN, 0) +} + +func (s *CreateServerContext) DATA() antlr.TerminalNode { + return s.GetToken(MySqlParserDATA, 0) +} + +func (s *CreateServerContext) WRAPPER() antlr.TerminalNode { + return s.GetToken(MySqlParserWRAPPER, 0) +} + +func (s *CreateServerContext) OPTIONS() antlr.TerminalNode { + return s.GetToken(MySqlParserOPTIONS, 0) +} + +func (s *CreateServerContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *CreateServerContext) AllServerOption() []IServerOptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IServerOptionContext); ok { + len++ + } + } + + tst := make([]IServerOptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IServerOptionContext); ok { + tst[i] = t.(IServerOptionContext) + i++ + } + } + + return tst +} + +func (s *CreateServerContext) ServerOption(i int) IServerOptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IServerOptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IServerOptionContext) +} + +func (s *CreateServerContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *CreateServerContext) MYSQL() antlr.TerminalNode { + return s.GetToken(MySqlParserMYSQL, 0) +} + +func (s *CreateServerContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *CreateServerContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *CreateServerContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *CreateServerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateServerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateServerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCreateServer(s) + } +} + +func (s *CreateServerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCreateServer(s) + } +} + +func (p *MySqlParser) CreateServer() (localctx ICreateServerContext) { + localctx = NewCreateServerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 38, MySqlParserRULE_createServer) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1110) + p.Match(MySqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1111) + p.Match(MySqlParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1112) + p.Uid() + } + { + p.SetState(1113) + p.Match(MySqlParserFOREIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1114) + p.Match(MySqlParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1115) + p.Match(MySqlParserWRAPPER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1116) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*CreateServerContext).wrapperName = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserMYSQL || _la == MySqlParserSTRING_LITERAL) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*CreateServerContext).wrapperName = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(1117) + p.Match(MySqlParserOPTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1118) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1119) + p.ServerOption() + } + p.SetState(1124) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(1120) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1121) + p.ServerOption() + } + + p.SetState(1126) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1127) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreateTableContext is an interface to support dynamic dispatch. +type ICreateTableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsCreateTableContext differentiates from other interfaces. + IsCreateTableContext() +} + +type CreateTableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreateTableContext() *CreateTableContext { + var p = new(CreateTableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_createTable + return p +} + +func InitEmptyCreateTableContext(p *CreateTableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_createTable +} + +func (*CreateTableContext) IsCreateTableContext() {} + +func NewCreateTableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateTableContext { + var p = new(CreateTableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_createTable + + return p +} + +func (s *CreateTableContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateTableContext) CopyAll(ctx *CreateTableContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *CreateTableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateTableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type CopyCreateTableContext struct { + CreateTableContext + parenthesisTable ITableNameContext +} + +func NewCopyCreateTableContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CopyCreateTableContext { + var p = new(CopyCreateTableContext) + + InitEmptyCreateTableContext(&p.CreateTableContext) + p.parser = parser + p.CopyAll(ctx.(*CreateTableContext)) + + return p +} + +func (s *CopyCreateTableContext) GetParenthesisTable() ITableNameContext { return s.parenthesisTable } + +func (s *CopyCreateTableContext) SetParenthesisTable(v ITableNameContext) { s.parenthesisTable = v } + +func (s *CopyCreateTableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CopyCreateTableContext) CREATE() antlr.TerminalNode { + return s.GetToken(MySqlParserCREATE, 0) +} + +func (s *CopyCreateTableContext) TABLE() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLE, 0) +} + +func (s *CopyCreateTableContext) AllTableName() []ITableNameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITableNameContext); ok { + len++ + } + } + + tst := make([]ITableNameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITableNameContext); ok { + tst[i] = t.(ITableNameContext) + i++ + } + } + + return tst +} + +func (s *CopyCreateTableContext) TableName(i int) ITableNameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableNameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITableNameContext) +} + +func (s *CopyCreateTableContext) LIKE() antlr.TerminalNode { + return s.GetToken(MySqlParserLIKE, 0) +} + +func (s *CopyCreateTableContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *CopyCreateTableContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *CopyCreateTableContext) TEMPORARY() antlr.TerminalNode { + return s.GetToken(MySqlParserTEMPORARY, 0) +} + +func (s *CopyCreateTableContext) IfNotExists() IIfNotExistsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfNotExistsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfNotExistsContext) +} + +func (s *CopyCreateTableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCopyCreateTable(s) + } +} + +func (s *CopyCreateTableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCopyCreateTable(s) + } +} + +type ColumnCreateTableContext struct { + CreateTableContext +} + +func NewColumnCreateTableContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ColumnCreateTableContext { + var p = new(ColumnCreateTableContext) + + InitEmptyCreateTableContext(&p.CreateTableContext) + p.parser = parser + p.CopyAll(ctx.(*CreateTableContext)) + + return p +} + +func (s *ColumnCreateTableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ColumnCreateTableContext) CREATE() antlr.TerminalNode { + return s.GetToken(MySqlParserCREATE, 0) +} + +func (s *ColumnCreateTableContext) TABLE() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLE, 0) +} + +func (s *ColumnCreateTableContext) TableName() ITableNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableNameContext) +} + +func (s *ColumnCreateTableContext) CreateDefinitions() ICreateDefinitionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateDefinitionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateDefinitionsContext) +} + +func (s *ColumnCreateTableContext) TEMPORARY() antlr.TerminalNode { + return s.GetToken(MySqlParserTEMPORARY, 0) +} + +func (s *ColumnCreateTableContext) IfNotExists() IIfNotExistsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfNotExistsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfNotExistsContext) +} + +func (s *ColumnCreateTableContext) AllTableOption() []ITableOptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITableOptionContext); ok { + len++ + } + } + + tst := make([]ITableOptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITableOptionContext); ok { + tst[i] = t.(ITableOptionContext) + i++ + } + } + + return tst +} + +func (s *ColumnCreateTableContext) TableOption(i int) ITableOptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableOptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITableOptionContext) +} + +func (s *ColumnCreateTableContext) PartitionDefinitions() IPartitionDefinitionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionDefinitionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartitionDefinitionsContext) +} + +func (s *ColumnCreateTableContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *ColumnCreateTableContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *ColumnCreateTableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterColumnCreateTable(s) + } +} + +func (s *ColumnCreateTableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitColumnCreateTable(s) + } +} + +type QueryCreateTableContext struct { + CreateTableContext + keyViolate antlr.Token +} + +func NewQueryCreateTableContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *QueryCreateTableContext { + var p = new(QueryCreateTableContext) + + InitEmptyCreateTableContext(&p.CreateTableContext) + p.parser = parser + p.CopyAll(ctx.(*CreateTableContext)) + + return p +} + +func (s *QueryCreateTableContext) GetKeyViolate() antlr.Token { return s.keyViolate } + +func (s *QueryCreateTableContext) SetKeyViolate(v antlr.Token) { s.keyViolate = v } + +func (s *QueryCreateTableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *QueryCreateTableContext) CREATE() antlr.TerminalNode { + return s.GetToken(MySqlParserCREATE, 0) +} + +func (s *QueryCreateTableContext) TABLE() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLE, 0) +} + +func (s *QueryCreateTableContext) TableName() ITableNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableNameContext) +} + +func (s *QueryCreateTableContext) SelectStatement() ISelectStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelectStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelectStatementContext) +} + +func (s *QueryCreateTableContext) TEMPORARY() antlr.TerminalNode { + return s.GetToken(MySqlParserTEMPORARY, 0) +} + +func (s *QueryCreateTableContext) IfNotExists() IIfNotExistsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfNotExistsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfNotExistsContext) +} + +func (s *QueryCreateTableContext) CreateDefinitions() ICreateDefinitionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateDefinitionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateDefinitionsContext) +} + +func (s *QueryCreateTableContext) AllTableOption() []ITableOptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITableOptionContext); ok { + len++ + } + } + + tst := make([]ITableOptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITableOptionContext); ok { + tst[i] = t.(ITableOptionContext) + i++ + } + } + + return tst +} + +func (s *QueryCreateTableContext) TableOption(i int) ITableOptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableOptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITableOptionContext) +} + +func (s *QueryCreateTableContext) PartitionDefinitions() IPartitionDefinitionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionDefinitionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartitionDefinitionsContext) +} + +func (s *QueryCreateTableContext) AS() antlr.TerminalNode { + return s.GetToken(MySqlParserAS, 0) +} + +func (s *QueryCreateTableContext) IGNORE() antlr.TerminalNode { + return s.GetToken(MySqlParserIGNORE, 0) +} + +func (s *QueryCreateTableContext) REPLACE() antlr.TerminalNode { + return s.GetToken(MySqlParserREPLACE, 0) +} + +func (s *QueryCreateTableContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *QueryCreateTableContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *QueryCreateTableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterQueryCreateTable(s) + } +} + +func (s *QueryCreateTableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitQueryCreateTable(s) + } +} + +func (p *MySqlParser) CreateTable() (localctx ICreateTableContext) { + localctx = NewCreateTableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 40, MySqlParserRULE_createTable) + var _la int + + var _alt int + + p.SetState(1207) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 78, p.GetParserRuleContext()) { + case 1: + localctx = NewCopyCreateTableContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1129) + p.Match(MySqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1131) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserTEMPORARY { + { + p.SetState(1130) + p.Match(MySqlParserTEMPORARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1133) + p.Match(MySqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1135) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 61, p.GetParserRuleContext()) == 1 { + { + p.SetState(1134) + p.IfNotExists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(1137) + p.TableName() + } + p.SetState(1145) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserLIKE: + { + p.SetState(1138) + p.Match(MySqlParserLIKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1139) + p.TableName() + } + + case MySqlParserLR_BRACKET: + { + p.SetState(1140) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1141) + p.Match(MySqlParserLIKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1142) + + var _x = p.TableName() + + localctx.(*CopyCreateTableContext).parenthesisTable = _x + } + { + p.SetState(1143) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 2: + localctx = NewQueryCreateTableContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1147) + p.Match(MySqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1149) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserTEMPORARY { + { + p.SetState(1148) + p.Match(MySqlParserTEMPORARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1151) + p.Match(MySqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1153) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 64, p.GetParserRuleContext()) == 1 { + { + p.SetState(1152) + p.IfNotExists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(1155) + p.TableName() + } + p.SetState(1157) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 65, p.GetParserRuleContext()) == 1 { + { + p.SetState(1156) + p.CreateDefinitions() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(1169) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-25)) & ^0x3f) == 0 && ((int64(1)<<(_la-25))&72057594038059013) != 0) || _la == MySqlParserUNION || _la == MySqlParserCHAR || ((int64((_la-342)) & ^0x3f) == 0 && ((int64(1)<<(_la-342))&4644375904747527) != 0) || ((int64((_la-406)) & ^0x3f) == 0 && ((int64(1)<<(_la-406))&4612811918334230547) != 0) || ((int64((_la-501)) & ^0x3f) == 0 && ((int64(1)<<(_la-501))&2366149022974977) != 0) || ((int64((_la-603)) & ^0x3f) == 0 && ((int64(1)<<(_la-603))&4609173815820289) != 0) || _la == MySqlParserCHARSET || _la == MySqlParserENGINE_ATTRIBUTE || _la == MySqlParserSECONDARY_ENGINE_ATTRIBUTE || _la == MySqlParserSTRING_LITERAL { + { + p.SetState(1159) + p.TableOption() + } + p.SetState(1166) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ((int64((_la-25)) & ^0x3f) == 0 && ((int64(1)<<(_la-25))&72057594038059013) != 0) || _la == MySqlParserUNION || _la == MySqlParserCHAR || ((int64((_la-342)) & ^0x3f) == 0 && ((int64(1)<<(_la-342))&4644375904747527) != 0) || ((int64((_la-406)) & ^0x3f) == 0 && ((int64(1)<<(_la-406))&4612811918334230547) != 0) || ((int64((_la-501)) & ^0x3f) == 0 && ((int64(1)<<(_la-501))&2366149022974977) != 0) || ((int64((_la-603)) & ^0x3f) == 0 && ((int64(1)<<(_la-603))&4609173815820289) != 0) || _la == MySqlParserCHARSET || _la == MySqlParserENGINE_ATTRIBUTE || _la == MySqlParserSECONDARY_ENGINE_ATTRIBUTE || _la == MySqlParserCOMMA || _la == MySqlParserSTRING_LITERAL { + p.SetState(1161) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserCOMMA { + { + p.SetState(1160) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1163) + p.TableOption() + } + + p.SetState(1168) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + p.SetState(1172) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserPARTITION { + { + p.SetState(1171) + p.PartitionDefinitions() + } + + } + p.SetState(1175) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserIGNORE || _la == MySqlParserREPLACE { + { + p.SetState(1174) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*QueryCreateTableContext).keyViolate = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserIGNORE || _la == MySqlParserREPLACE) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*QueryCreateTableContext).keyViolate = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(1178) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserAS { + { + p.SetState(1177) + p.Match(MySqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1180) + p.SelectStatement() + } + + case 3: + localctx = NewColumnCreateTableContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1182) + p.Match(MySqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1184) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserTEMPORARY { + { + p.SetState(1183) + p.Match(MySqlParserTEMPORARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1186) + p.Match(MySqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1188) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 73, p.GetParserRuleContext()) == 1 { + { + p.SetState(1187) + p.IfNotExists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(1190) + p.TableName() + } + { + p.SetState(1191) + p.CreateDefinitions() + } + p.SetState(1202) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 76, p.GetParserRuleContext()) == 1 { + { + p.SetState(1192) + p.TableOption() + } + p.SetState(1199) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 75, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(1194) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserCOMMA { + { + p.SetState(1193) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1196) + p.TableOption() + } + + } + p.SetState(1201) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 75, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(1205) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserPARTITION { + { + p.SetState(1204) + p.PartitionDefinitions() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreateTablespaceInnodbContext is an interface to support dynamic dispatch. +type ICreateTablespaceInnodbContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetDatafile returns the datafile token. + GetDatafile() antlr.Token + + // SetDatafile sets the datafile token. + SetDatafile(antlr.Token) + + // GetFileBlockSize returns the fileBlockSize rule contexts. + GetFileBlockSize() IFileSizeLiteralContext + + // SetFileBlockSize sets the fileBlockSize rule contexts. + SetFileBlockSize(IFileSizeLiteralContext) + + // Getter signatures + CREATE() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + Uid() IUidContext + ADD() antlr.TerminalNode + DATAFILE() antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + FILE_BLOCK_SIZE() antlr.TerminalNode + AllEQUAL_SYMBOL() []antlr.TerminalNode + EQUAL_SYMBOL(i int) antlr.TerminalNode + ENGINE() antlr.TerminalNode + EngineName() IEngineNameContext + FileSizeLiteral() IFileSizeLiteralContext + + // IsCreateTablespaceInnodbContext differentiates from other interfaces. + IsCreateTablespaceInnodbContext() +} + +type CreateTablespaceInnodbContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + datafile antlr.Token + fileBlockSize IFileSizeLiteralContext +} + +func NewEmptyCreateTablespaceInnodbContext() *CreateTablespaceInnodbContext { + var p = new(CreateTablespaceInnodbContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_createTablespaceInnodb + return p +} + +func InitEmptyCreateTablespaceInnodbContext(p *CreateTablespaceInnodbContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_createTablespaceInnodb +} + +func (*CreateTablespaceInnodbContext) IsCreateTablespaceInnodbContext() {} + +func NewCreateTablespaceInnodbContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateTablespaceInnodbContext { + var p = new(CreateTablespaceInnodbContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_createTablespaceInnodb + + return p +} + +func (s *CreateTablespaceInnodbContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateTablespaceInnodbContext) GetDatafile() antlr.Token { return s.datafile } + +func (s *CreateTablespaceInnodbContext) SetDatafile(v antlr.Token) { s.datafile = v } + +func (s *CreateTablespaceInnodbContext) GetFileBlockSize() IFileSizeLiteralContext { + return s.fileBlockSize +} + +func (s *CreateTablespaceInnodbContext) SetFileBlockSize(v IFileSizeLiteralContext) { + s.fileBlockSize = v +} + +func (s *CreateTablespaceInnodbContext) CREATE() antlr.TerminalNode { + return s.GetToken(MySqlParserCREATE, 0) +} + +func (s *CreateTablespaceInnodbContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLESPACE, 0) +} + +func (s *CreateTablespaceInnodbContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *CreateTablespaceInnodbContext) ADD() antlr.TerminalNode { + return s.GetToken(MySqlParserADD, 0) +} + +func (s *CreateTablespaceInnodbContext) DATAFILE() antlr.TerminalNode { + return s.GetToken(MySqlParserDATAFILE, 0) +} + +func (s *CreateTablespaceInnodbContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *CreateTablespaceInnodbContext) FILE_BLOCK_SIZE() antlr.TerminalNode { + return s.GetToken(MySqlParserFILE_BLOCK_SIZE, 0) +} + +func (s *CreateTablespaceInnodbContext) AllEQUAL_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(MySqlParserEQUAL_SYMBOL) +} + +func (s *CreateTablespaceInnodbContext) EQUAL_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, i) +} + +func (s *CreateTablespaceInnodbContext) ENGINE() antlr.TerminalNode { + return s.GetToken(MySqlParserENGINE, 0) +} + +func (s *CreateTablespaceInnodbContext) EngineName() IEngineNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEngineNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEngineNameContext) +} + +func (s *CreateTablespaceInnodbContext) FileSizeLiteral() IFileSizeLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFileSizeLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFileSizeLiteralContext) +} + +func (s *CreateTablespaceInnodbContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateTablespaceInnodbContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateTablespaceInnodbContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCreateTablespaceInnodb(s) + } +} + +func (s *CreateTablespaceInnodbContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCreateTablespaceInnodb(s) + } +} + +func (p *MySqlParser) CreateTablespaceInnodb() (localctx ICreateTablespaceInnodbContext) { + localctx = NewCreateTablespaceInnodbContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 42, MySqlParserRULE_createTablespaceInnodb) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1209) + p.Match(MySqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1210) + p.Match(MySqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1211) + p.Uid() + } + { + p.SetState(1212) + p.Match(MySqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1213) + p.Match(MySqlParserDATAFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1214) + + var _m = p.Match(MySqlParserSTRING_LITERAL) + + localctx.(*CreateTablespaceInnodbContext).datafile = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1218) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserFILE_BLOCK_SIZE { + { + p.SetState(1215) + p.Match(MySqlParserFILE_BLOCK_SIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1216) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1217) + + var _x = p.FileSizeLiteral() + + localctx.(*CreateTablespaceInnodbContext).fileBlockSize = _x + } + + } + p.SetState(1225) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserENGINE { + { + p.SetState(1220) + p.Match(MySqlParserENGINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1222) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1221) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1224) + p.EngineName() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreateTablespaceNdbContext is an interface to support dynamic dispatch. +type ICreateTablespaceNdbContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetDatafile returns the datafile token. + GetDatafile() antlr.Token + + // GetComment returns the comment token. + GetComment() antlr.Token + + // SetDatafile sets the datafile token. + SetDatafile(antlr.Token) + + // SetComment sets the comment token. + SetComment(antlr.Token) + + // GetExtentSize returns the extentSize rule contexts. + GetExtentSize() IFileSizeLiteralContext + + // GetInitialSize returns the initialSize rule contexts. + GetInitialSize() IFileSizeLiteralContext + + // GetAutoextendSize returns the autoextendSize rule contexts. + GetAutoextendSize() IFileSizeLiteralContext + + // GetMaxSize returns the maxSize rule contexts. + GetMaxSize() IFileSizeLiteralContext + + // SetExtentSize sets the extentSize rule contexts. + SetExtentSize(IFileSizeLiteralContext) + + // SetInitialSize sets the initialSize rule contexts. + SetInitialSize(IFileSizeLiteralContext) + + // SetAutoextendSize sets the autoextendSize rule contexts. + SetAutoextendSize(IFileSizeLiteralContext) + + // SetMaxSize sets the maxSize rule contexts. + SetMaxSize(IFileSizeLiteralContext) + + // Getter signatures + CREATE() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + AllUid() []IUidContext + Uid(i int) IUidContext + ADD() antlr.TerminalNode + DATAFILE() antlr.TerminalNode + USE() antlr.TerminalNode + LOGFILE() antlr.TerminalNode + GROUP() antlr.TerminalNode + ENGINE() antlr.TerminalNode + EngineName() IEngineNameContext + AllSTRING_LITERAL() []antlr.TerminalNode + STRING_LITERAL(i int) antlr.TerminalNode + EXTENT_SIZE() antlr.TerminalNode + INITIAL_SIZE() antlr.TerminalNode + AUTOEXTEND_SIZE() antlr.TerminalNode + MAX_SIZE() antlr.TerminalNode + NODEGROUP() antlr.TerminalNode + WAIT() antlr.TerminalNode + COMMENT() antlr.TerminalNode + AllEQUAL_SYMBOL() []antlr.TerminalNode + EQUAL_SYMBOL(i int) antlr.TerminalNode + AllFileSizeLiteral() []IFileSizeLiteralContext + FileSizeLiteral(i int) IFileSizeLiteralContext + + // IsCreateTablespaceNdbContext differentiates from other interfaces. + IsCreateTablespaceNdbContext() +} + +type CreateTablespaceNdbContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + datafile antlr.Token + extentSize IFileSizeLiteralContext + initialSize IFileSizeLiteralContext + autoextendSize IFileSizeLiteralContext + maxSize IFileSizeLiteralContext + comment antlr.Token +} + +func NewEmptyCreateTablespaceNdbContext() *CreateTablespaceNdbContext { + var p = new(CreateTablespaceNdbContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_createTablespaceNdb + return p +} + +func InitEmptyCreateTablespaceNdbContext(p *CreateTablespaceNdbContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_createTablespaceNdb +} + +func (*CreateTablespaceNdbContext) IsCreateTablespaceNdbContext() {} + +func NewCreateTablespaceNdbContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateTablespaceNdbContext { + var p = new(CreateTablespaceNdbContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_createTablespaceNdb + + return p +} + +func (s *CreateTablespaceNdbContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateTablespaceNdbContext) GetDatafile() antlr.Token { return s.datafile } + +func (s *CreateTablespaceNdbContext) GetComment() antlr.Token { return s.comment } + +func (s *CreateTablespaceNdbContext) SetDatafile(v antlr.Token) { s.datafile = v } + +func (s *CreateTablespaceNdbContext) SetComment(v antlr.Token) { s.comment = v } + +func (s *CreateTablespaceNdbContext) GetExtentSize() IFileSizeLiteralContext { return s.extentSize } + +func (s *CreateTablespaceNdbContext) GetInitialSize() IFileSizeLiteralContext { return s.initialSize } + +func (s *CreateTablespaceNdbContext) GetAutoextendSize() IFileSizeLiteralContext { + return s.autoextendSize +} + +func (s *CreateTablespaceNdbContext) GetMaxSize() IFileSizeLiteralContext { return s.maxSize } + +func (s *CreateTablespaceNdbContext) SetExtentSize(v IFileSizeLiteralContext) { s.extentSize = v } + +func (s *CreateTablespaceNdbContext) SetInitialSize(v IFileSizeLiteralContext) { s.initialSize = v } + +func (s *CreateTablespaceNdbContext) SetAutoextendSize(v IFileSizeLiteralContext) { + s.autoextendSize = v +} + +func (s *CreateTablespaceNdbContext) SetMaxSize(v IFileSizeLiteralContext) { s.maxSize = v } + +func (s *CreateTablespaceNdbContext) CREATE() antlr.TerminalNode { + return s.GetToken(MySqlParserCREATE, 0) +} + +func (s *CreateTablespaceNdbContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLESPACE, 0) +} + +func (s *CreateTablespaceNdbContext) AllUid() []IUidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUidContext); ok { + len++ + } + } + + tst := make([]IUidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUidContext); ok { + tst[i] = t.(IUidContext) + i++ + } + } + + return tst +} + +func (s *CreateTablespaceNdbContext) Uid(i int) IUidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *CreateTablespaceNdbContext) ADD() antlr.TerminalNode { + return s.GetToken(MySqlParserADD, 0) +} + +func (s *CreateTablespaceNdbContext) DATAFILE() antlr.TerminalNode { + return s.GetToken(MySqlParserDATAFILE, 0) +} + +func (s *CreateTablespaceNdbContext) USE() antlr.TerminalNode { + return s.GetToken(MySqlParserUSE, 0) +} + +func (s *CreateTablespaceNdbContext) LOGFILE() antlr.TerminalNode { + return s.GetToken(MySqlParserLOGFILE, 0) +} + +func (s *CreateTablespaceNdbContext) GROUP() antlr.TerminalNode { + return s.GetToken(MySqlParserGROUP, 0) +} + +func (s *CreateTablespaceNdbContext) ENGINE() antlr.TerminalNode { + return s.GetToken(MySqlParserENGINE, 0) +} + +func (s *CreateTablespaceNdbContext) EngineName() IEngineNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEngineNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEngineNameContext) +} + +func (s *CreateTablespaceNdbContext) AllSTRING_LITERAL() []antlr.TerminalNode { + return s.GetTokens(MySqlParserSTRING_LITERAL) +} + +func (s *CreateTablespaceNdbContext) STRING_LITERAL(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, i) +} + +func (s *CreateTablespaceNdbContext) EXTENT_SIZE() antlr.TerminalNode { + return s.GetToken(MySqlParserEXTENT_SIZE, 0) +} + +func (s *CreateTablespaceNdbContext) INITIAL_SIZE() antlr.TerminalNode { + return s.GetToken(MySqlParserINITIAL_SIZE, 0) +} + +func (s *CreateTablespaceNdbContext) AUTOEXTEND_SIZE() antlr.TerminalNode { + return s.GetToken(MySqlParserAUTOEXTEND_SIZE, 0) +} + +func (s *CreateTablespaceNdbContext) MAX_SIZE() antlr.TerminalNode { + return s.GetToken(MySqlParserMAX_SIZE, 0) +} + +func (s *CreateTablespaceNdbContext) NODEGROUP() antlr.TerminalNode { + return s.GetToken(MySqlParserNODEGROUP, 0) +} + +func (s *CreateTablespaceNdbContext) WAIT() antlr.TerminalNode { + return s.GetToken(MySqlParserWAIT, 0) +} + +func (s *CreateTablespaceNdbContext) COMMENT() antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMENT, 0) +} + +func (s *CreateTablespaceNdbContext) AllEQUAL_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(MySqlParserEQUAL_SYMBOL) +} + +func (s *CreateTablespaceNdbContext) EQUAL_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, i) +} + +func (s *CreateTablespaceNdbContext) AllFileSizeLiteral() []IFileSizeLiteralContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFileSizeLiteralContext); ok { + len++ + } + } + + tst := make([]IFileSizeLiteralContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFileSizeLiteralContext); ok { + tst[i] = t.(IFileSizeLiteralContext) + i++ + } + } + + return tst +} + +func (s *CreateTablespaceNdbContext) FileSizeLiteral(i int) IFileSizeLiteralContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFileSizeLiteralContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFileSizeLiteralContext) +} + +func (s *CreateTablespaceNdbContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateTablespaceNdbContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateTablespaceNdbContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCreateTablespaceNdb(s) + } +} + +func (s *CreateTablespaceNdbContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCreateTablespaceNdb(s) + } +} + +func (p *MySqlParser) CreateTablespaceNdb() (localctx ICreateTablespaceNdbContext) { + localctx = NewCreateTablespaceNdbContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 44, MySqlParserRULE_createTablespaceNdb) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1227) + p.Match(MySqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1228) + p.Match(MySqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1229) + p.Uid() + } + { + p.SetState(1230) + p.Match(MySqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1231) + p.Match(MySqlParserDATAFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1232) + + var _m = p.Match(MySqlParserSTRING_LITERAL) + + localctx.(*CreateTablespaceNdbContext).datafile = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1233) + p.Match(MySqlParserUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1234) + p.Match(MySqlParserLOGFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1235) + p.Match(MySqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1236) + p.Uid() + } + p.SetState(1242) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEXTENT_SIZE { + { + p.SetState(1237) + p.Match(MySqlParserEXTENT_SIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1239) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1238) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1241) + + var _x = p.FileSizeLiteral() + + localctx.(*CreateTablespaceNdbContext).extentSize = _x + } + + } + p.SetState(1249) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserINITIAL_SIZE { + { + p.SetState(1244) + p.Match(MySqlParserINITIAL_SIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1246) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1245) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1248) + + var _x = p.FileSizeLiteral() + + localctx.(*CreateTablespaceNdbContext).initialSize = _x + } + + } + p.SetState(1256) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserAUTOEXTEND_SIZE { + { + p.SetState(1251) + p.Match(MySqlParserAUTOEXTEND_SIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1253) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1252) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1255) + + var _x = p.FileSizeLiteral() + + localctx.(*CreateTablespaceNdbContext).autoextendSize = _x + } + + } + p.SetState(1263) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserMAX_SIZE { + { + p.SetState(1258) + p.Match(MySqlParserMAX_SIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1260) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1259) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1262) + + var _x = p.FileSizeLiteral() + + localctx.(*CreateTablespaceNdbContext).maxSize = _x + } + + } + p.SetState(1270) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserNODEGROUP { + { + p.SetState(1265) + p.Match(MySqlParserNODEGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1267) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1266) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1269) + p.Uid() + } + + } + p.SetState(1273) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserWAIT { + { + p.SetState(1272) + p.Match(MySqlParserWAIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(1280) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserCOMMENT { + { + p.SetState(1275) + p.Match(MySqlParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1277) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1276) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1279) + + var _m = p.Match(MySqlParserSTRING_LITERAL) + + localctx.(*CreateTablespaceNdbContext).comment = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1282) + p.Match(MySqlParserENGINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1284) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1283) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1286) + p.EngineName() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreateTriggerContext is an interface to support dynamic dispatch. +type ICreateTriggerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetTriggerTime returns the triggerTime token. + GetTriggerTime() antlr.Token + + // GetTriggerEvent returns the triggerEvent token. + GetTriggerEvent() antlr.Token + + // GetTriggerPlace returns the triggerPlace token. + GetTriggerPlace() antlr.Token + + // SetTriggerTime sets the triggerTime token. + SetTriggerTime(antlr.Token) + + // SetTriggerEvent sets the triggerEvent token. + SetTriggerEvent(antlr.Token) + + // SetTriggerPlace sets the triggerPlace token. + SetTriggerPlace(antlr.Token) + + // GetThisTrigger returns the thisTrigger rule contexts. + GetThisTrigger() IFullIdContext + + // GetOtherTrigger returns the otherTrigger rule contexts. + GetOtherTrigger() IFullIdContext + + // SetThisTrigger sets the thisTrigger rule contexts. + SetThisTrigger(IFullIdContext) + + // SetOtherTrigger sets the otherTrigger rule contexts. + SetOtherTrigger(IFullIdContext) + + // Getter signatures + CREATE() antlr.TerminalNode + TRIGGER() antlr.TerminalNode + ON() antlr.TerminalNode + TableName() ITableNameContext + FOR() antlr.TerminalNode + EACH() antlr.TerminalNode + ROW() antlr.TerminalNode + RoutineBody() IRoutineBodyContext + AllFullId() []IFullIdContext + FullId(i int) IFullIdContext + BEFORE() antlr.TerminalNode + AFTER() antlr.TerminalNode + INSERT() antlr.TerminalNode + UPDATE() antlr.TerminalNode + DELETE() antlr.TerminalNode + OwnerStatement() IOwnerStatementContext + IfNotExists() IIfNotExistsContext + FOLLOWS() antlr.TerminalNode + PRECEDES() antlr.TerminalNode + + // IsCreateTriggerContext differentiates from other interfaces. + IsCreateTriggerContext() +} + +type CreateTriggerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + thisTrigger IFullIdContext + triggerTime antlr.Token + triggerEvent antlr.Token + triggerPlace antlr.Token + otherTrigger IFullIdContext +} + +func NewEmptyCreateTriggerContext() *CreateTriggerContext { + var p = new(CreateTriggerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_createTrigger + return p +} + +func InitEmptyCreateTriggerContext(p *CreateTriggerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_createTrigger +} + +func (*CreateTriggerContext) IsCreateTriggerContext() {} + +func NewCreateTriggerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateTriggerContext { + var p = new(CreateTriggerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_createTrigger + + return p +} + +func (s *CreateTriggerContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateTriggerContext) GetTriggerTime() antlr.Token { return s.triggerTime } + +func (s *CreateTriggerContext) GetTriggerEvent() antlr.Token { return s.triggerEvent } + +func (s *CreateTriggerContext) GetTriggerPlace() antlr.Token { return s.triggerPlace } + +func (s *CreateTriggerContext) SetTriggerTime(v antlr.Token) { s.triggerTime = v } + +func (s *CreateTriggerContext) SetTriggerEvent(v antlr.Token) { s.triggerEvent = v } + +func (s *CreateTriggerContext) SetTriggerPlace(v antlr.Token) { s.triggerPlace = v } + +func (s *CreateTriggerContext) GetThisTrigger() IFullIdContext { return s.thisTrigger } + +func (s *CreateTriggerContext) GetOtherTrigger() IFullIdContext { return s.otherTrigger } + +func (s *CreateTriggerContext) SetThisTrigger(v IFullIdContext) { s.thisTrigger = v } + +func (s *CreateTriggerContext) SetOtherTrigger(v IFullIdContext) { s.otherTrigger = v } + +func (s *CreateTriggerContext) CREATE() antlr.TerminalNode { + return s.GetToken(MySqlParserCREATE, 0) +} + +func (s *CreateTriggerContext) TRIGGER() antlr.TerminalNode { + return s.GetToken(MySqlParserTRIGGER, 0) +} + +func (s *CreateTriggerContext) ON() antlr.TerminalNode { + return s.GetToken(MySqlParserON, 0) +} + +func (s *CreateTriggerContext) TableName() ITableNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableNameContext) +} + +func (s *CreateTriggerContext) FOR() antlr.TerminalNode { + return s.GetToken(MySqlParserFOR, 0) +} + +func (s *CreateTriggerContext) EACH() antlr.TerminalNode { + return s.GetToken(MySqlParserEACH, 0) +} + +func (s *CreateTriggerContext) ROW() antlr.TerminalNode { + return s.GetToken(MySqlParserROW, 0) +} + +func (s *CreateTriggerContext) RoutineBody() IRoutineBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRoutineBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRoutineBodyContext) +} + +func (s *CreateTriggerContext) AllFullId() []IFullIdContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFullIdContext); ok { + len++ + } + } + + tst := make([]IFullIdContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFullIdContext); ok { + tst[i] = t.(IFullIdContext) + i++ + } + } + + return tst +} + +func (s *CreateTriggerContext) FullId(i int) IFullIdContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFullIdContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFullIdContext) +} + +func (s *CreateTriggerContext) BEFORE() antlr.TerminalNode { + return s.GetToken(MySqlParserBEFORE, 0) +} + +func (s *CreateTriggerContext) AFTER() antlr.TerminalNode { + return s.GetToken(MySqlParserAFTER, 0) +} + +func (s *CreateTriggerContext) INSERT() antlr.TerminalNode { + return s.GetToken(MySqlParserINSERT, 0) +} + +func (s *CreateTriggerContext) UPDATE() antlr.TerminalNode { + return s.GetToken(MySqlParserUPDATE, 0) +} + +func (s *CreateTriggerContext) DELETE() antlr.TerminalNode { + return s.GetToken(MySqlParserDELETE, 0) +} + +func (s *CreateTriggerContext) OwnerStatement() IOwnerStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOwnerStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOwnerStatementContext) +} + +func (s *CreateTriggerContext) IfNotExists() IIfNotExistsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfNotExistsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfNotExistsContext) +} + +func (s *CreateTriggerContext) FOLLOWS() antlr.TerminalNode { + return s.GetToken(MySqlParserFOLLOWS, 0) +} + +func (s *CreateTriggerContext) PRECEDES() antlr.TerminalNode { + return s.GetToken(MySqlParserPRECEDES, 0) +} + +func (s *CreateTriggerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateTriggerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateTriggerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCreateTrigger(s) + } +} + +func (s *CreateTriggerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCreateTrigger(s) + } +} + +func (p *MySqlParser) CreateTrigger() (localctx ICreateTriggerContext) { + localctx = NewCreateTriggerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 46, MySqlParserRULE_createTrigger) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1288) + p.Match(MySqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1290) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserDEFINER { + { + p.SetState(1289) + p.OwnerStatement() + } + + } + { + p.SetState(1292) + p.Match(MySqlParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1294) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 97, p.GetParserRuleContext()) == 1 { + { + p.SetState(1293) + p.IfNotExists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(1296) + + var _x = p.FullId() + + localctx.(*CreateTriggerContext).thisTrigger = _x + } + { + p.SetState(1297) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*CreateTriggerContext).triggerTime = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserBEFORE || _la == MySqlParserAFTER) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*CreateTriggerContext).triggerTime = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(1298) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*CreateTriggerContext).triggerEvent = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserDELETE || _la == MySqlParserINSERT || _la == MySqlParserUPDATE) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*CreateTriggerContext).triggerEvent = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(1299) + p.Match(MySqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1300) + p.TableName() + } + { + p.SetState(1301) + p.Match(MySqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1302) + p.Match(MySqlParserEACH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1303) + p.Match(MySqlParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1306) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 98, p.GetParserRuleContext()) == 1 { + { + p.SetState(1304) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*CreateTriggerContext).triggerPlace = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserFOLLOWS || _la == MySqlParserPRECEDES) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*CreateTriggerContext).triggerPlace = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(1305) + + var _x = p.FullId() + + localctx.(*CreateTriggerContext).otherTrigger = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(1308) + p.RoutineBody() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWithClauseContext is an interface to support dynamic dispatch. +type IWithClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH() antlr.TerminalNode + CommonTableExpressions() ICommonTableExpressionsContext + RECURSIVE() antlr.TerminalNode + + // IsWithClauseContext differentiates from other interfaces. + IsWithClauseContext() +} + +type WithClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWithClauseContext() *WithClauseContext { + var p = new(WithClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_withClause + return p +} + +func InitEmptyWithClauseContext(p *WithClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_withClause +} + +func (*WithClauseContext) IsWithClauseContext() {} + +func NewWithClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WithClauseContext { + var p = new(WithClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_withClause + + return p +} + +func (s *WithClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *WithClauseContext) WITH() antlr.TerminalNode { + return s.GetToken(MySqlParserWITH, 0) +} + +func (s *WithClauseContext) CommonTableExpressions() ICommonTableExpressionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICommonTableExpressionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICommonTableExpressionsContext) +} + +func (s *WithClauseContext) RECURSIVE() antlr.TerminalNode { + return s.GetToken(MySqlParserRECURSIVE, 0) +} + +func (s *WithClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *WithClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *WithClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterWithClause(s) + } +} + +func (s *WithClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitWithClause(s) + } +} + +func (p *MySqlParser) WithClause() (localctx IWithClauseContext) { + localctx = NewWithClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 48, MySqlParserRULE_withClause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1310) + p.Match(MySqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1312) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 99, p.GetParserRuleContext()) == 1 { + { + p.SetState(1311) + p.Match(MySqlParserRECURSIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(1314) + p.CommonTableExpressions() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICommonTableExpressionsContext is an interface to support dynamic dispatch. +type ICommonTableExpressionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CteName() ICteNameContext + AS() antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + DmlStatement() IDmlStatementContext + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + AllCteColumnName() []ICteColumnNameContext + CteColumnName(i int) ICteColumnNameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + CommonTableExpressions() ICommonTableExpressionsContext + + // IsCommonTableExpressionsContext differentiates from other interfaces. + IsCommonTableExpressionsContext() +} + +type CommonTableExpressionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCommonTableExpressionsContext() *CommonTableExpressionsContext { + var p = new(CommonTableExpressionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_commonTableExpressions + return p +} + +func InitEmptyCommonTableExpressionsContext(p *CommonTableExpressionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_commonTableExpressions +} + +func (*CommonTableExpressionsContext) IsCommonTableExpressionsContext() {} + +func NewCommonTableExpressionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CommonTableExpressionsContext { + var p = new(CommonTableExpressionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_commonTableExpressions + + return p +} + +func (s *CommonTableExpressionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *CommonTableExpressionsContext) CteName() ICteNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICteNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICteNameContext) +} + +func (s *CommonTableExpressionsContext) AS() antlr.TerminalNode { + return s.GetToken(MySqlParserAS, 0) +} + +func (s *CommonTableExpressionsContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(MySqlParserLR_BRACKET) +} + +func (s *CommonTableExpressionsContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, i) +} + +func (s *CommonTableExpressionsContext) DmlStatement() IDmlStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDmlStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDmlStatementContext) +} + +func (s *CommonTableExpressionsContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(MySqlParserRR_BRACKET) +} + +func (s *CommonTableExpressionsContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, i) +} + +func (s *CommonTableExpressionsContext) AllCteColumnName() []ICteColumnNameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICteColumnNameContext); ok { + len++ + } + } + + tst := make([]ICteColumnNameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICteColumnNameContext); ok { + tst[i] = t.(ICteColumnNameContext) + i++ + } + } + + return tst +} + +func (s *CommonTableExpressionsContext) CteColumnName(i int) ICteColumnNameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICteColumnNameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICteColumnNameContext) +} + +func (s *CommonTableExpressionsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *CommonTableExpressionsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *CommonTableExpressionsContext) CommonTableExpressions() ICommonTableExpressionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICommonTableExpressionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICommonTableExpressionsContext) +} + +func (s *CommonTableExpressionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CommonTableExpressionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CommonTableExpressionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCommonTableExpressions(s) + } +} + +func (s *CommonTableExpressionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCommonTableExpressions(s) + } +} + +func (p *MySqlParser) CommonTableExpressions() (localctx ICommonTableExpressionsContext) { + localctx = NewCommonTableExpressionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 50, MySqlParserRULE_commonTableExpressions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1316) + p.CteName() + } + p.SetState(1328) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserLR_BRACKET { + { + p.SetState(1317) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1318) + p.CteColumnName() + } + p.SetState(1323) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(1319) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1320) + p.CteColumnName() + } + + p.SetState(1325) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1326) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1330) + p.Match(MySqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1331) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1332) + p.DmlStatement() + } + { + p.SetState(1333) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1336) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 102, p.GetParserRuleContext()) == 1 { + { + p.SetState(1334) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1335) + p.CommonTableExpressions() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICteNameContext is an interface to support dynamic dispatch. +type ICteNameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Uid() IUidContext + + // IsCteNameContext differentiates from other interfaces. + IsCteNameContext() +} + +type CteNameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCteNameContext() *CteNameContext { + var p = new(CteNameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_cteName + return p +} + +func InitEmptyCteNameContext(p *CteNameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_cteName +} + +func (*CteNameContext) IsCteNameContext() {} + +func NewCteNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CteNameContext { + var p = new(CteNameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_cteName + + return p +} + +func (s *CteNameContext) GetParser() antlr.Parser { return s.parser } + +func (s *CteNameContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *CteNameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CteNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CteNameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCteName(s) + } +} + +func (s *CteNameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCteName(s) + } +} + +func (p *MySqlParser) CteName() (localctx ICteNameContext) { + localctx = NewCteNameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 52, MySqlParserRULE_cteName) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1338) + p.Uid() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICteColumnNameContext is an interface to support dynamic dispatch. +type ICteColumnNameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Uid() IUidContext + + // IsCteColumnNameContext differentiates from other interfaces. + IsCteColumnNameContext() +} + +type CteColumnNameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCteColumnNameContext() *CteColumnNameContext { + var p = new(CteColumnNameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_cteColumnName + return p +} + +func InitEmptyCteColumnNameContext(p *CteColumnNameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_cteColumnName +} + +func (*CteColumnNameContext) IsCteColumnNameContext() {} + +func NewCteColumnNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CteColumnNameContext { + var p = new(CteColumnNameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_cteColumnName + + return p +} + +func (s *CteColumnNameContext) GetParser() antlr.Parser { return s.parser } + +func (s *CteColumnNameContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *CteColumnNameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CteColumnNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CteColumnNameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCteColumnName(s) + } +} + +func (s *CteColumnNameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCteColumnName(s) + } +} + +func (p *MySqlParser) CteColumnName() (localctx ICteColumnNameContext) { + localctx = NewCteColumnNameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 54, MySqlParserRULE_cteColumnName) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1340) + p.Uid() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreateViewContext is an interface to support dynamic dispatch. +type ICreateViewContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetAlgType returns the algType token. + GetAlgType() antlr.Token + + // GetSecContext returns the secContext token. + GetSecContext() antlr.Token + + // GetCheckOption returns the checkOption token. + GetCheckOption() antlr.Token + + // SetAlgType sets the algType token. + SetAlgType(antlr.Token) + + // SetSecContext sets the secContext token. + SetSecContext(antlr.Token) + + // SetCheckOption sets the checkOption token. + SetCheckOption(antlr.Token) + + // Getter signatures + CREATE() antlr.TerminalNode + VIEW() antlr.TerminalNode + FullId() IFullIdContext + AS() antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + SelectStatement() ISelectStatementContext + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + OrReplace() IOrReplaceContext + ALGORITHM() antlr.TerminalNode + EQUAL_SYMBOL() antlr.TerminalNode + OwnerStatement() IOwnerStatementContext + SQL() antlr.TerminalNode + SECURITY() antlr.TerminalNode + UidList() IUidListContext + UNDEFINED() antlr.TerminalNode + MERGE() antlr.TerminalNode + TEMPTABLE() antlr.TerminalNode + DEFINER() antlr.TerminalNode + INVOKER() antlr.TerminalNode + WithClause() IWithClauseContext + WITH() antlr.TerminalNode + CHECK() antlr.TerminalNode + OPTION() antlr.TerminalNode + CASCADED() antlr.TerminalNode + LOCAL() antlr.TerminalNode + + // IsCreateViewContext differentiates from other interfaces. + IsCreateViewContext() +} + +type CreateViewContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + algType antlr.Token + secContext antlr.Token + checkOption antlr.Token +} + +func NewEmptyCreateViewContext() *CreateViewContext { + var p = new(CreateViewContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_createView + return p +} + +func InitEmptyCreateViewContext(p *CreateViewContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_createView +} + +func (*CreateViewContext) IsCreateViewContext() {} + +func NewCreateViewContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateViewContext { + var p = new(CreateViewContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_createView + + return p +} + +func (s *CreateViewContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateViewContext) GetAlgType() antlr.Token { return s.algType } + +func (s *CreateViewContext) GetSecContext() antlr.Token { return s.secContext } + +func (s *CreateViewContext) GetCheckOption() antlr.Token { return s.checkOption } + +func (s *CreateViewContext) SetAlgType(v antlr.Token) { s.algType = v } + +func (s *CreateViewContext) SetSecContext(v antlr.Token) { s.secContext = v } + +func (s *CreateViewContext) SetCheckOption(v antlr.Token) { s.checkOption = v } + +func (s *CreateViewContext) CREATE() antlr.TerminalNode { + return s.GetToken(MySqlParserCREATE, 0) +} + +func (s *CreateViewContext) VIEW() antlr.TerminalNode { + return s.GetToken(MySqlParserVIEW, 0) +} + +func (s *CreateViewContext) FullId() IFullIdContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFullIdContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFullIdContext) +} + +func (s *CreateViewContext) AS() antlr.TerminalNode { + return s.GetToken(MySqlParserAS, 0) +} + +func (s *CreateViewContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(MySqlParserLR_BRACKET) +} + +func (s *CreateViewContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, i) +} + +func (s *CreateViewContext) SelectStatement() ISelectStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelectStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelectStatementContext) +} + +func (s *CreateViewContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(MySqlParserRR_BRACKET) +} + +func (s *CreateViewContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, i) +} + +func (s *CreateViewContext) OrReplace() IOrReplaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOrReplaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOrReplaceContext) +} + +func (s *CreateViewContext) ALGORITHM() antlr.TerminalNode { + return s.GetToken(MySqlParserALGORITHM, 0) +} + +func (s *CreateViewContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *CreateViewContext) OwnerStatement() IOwnerStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOwnerStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOwnerStatementContext) +} + +func (s *CreateViewContext) SQL() antlr.TerminalNode { + return s.GetToken(MySqlParserSQL, 0) +} + +func (s *CreateViewContext) SECURITY() antlr.TerminalNode { + return s.GetToken(MySqlParserSECURITY, 0) +} + +func (s *CreateViewContext) UidList() IUidListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidListContext) +} + +func (s *CreateViewContext) UNDEFINED() antlr.TerminalNode { + return s.GetToken(MySqlParserUNDEFINED, 0) +} + +func (s *CreateViewContext) MERGE() antlr.TerminalNode { + return s.GetToken(MySqlParserMERGE, 0) +} + +func (s *CreateViewContext) TEMPTABLE() antlr.TerminalNode { + return s.GetToken(MySqlParserTEMPTABLE, 0) +} + +func (s *CreateViewContext) DEFINER() antlr.TerminalNode { + return s.GetToken(MySqlParserDEFINER, 0) +} + +func (s *CreateViewContext) INVOKER() antlr.TerminalNode { + return s.GetToken(MySqlParserINVOKER, 0) +} + +func (s *CreateViewContext) WithClause() IWithClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWithClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWithClauseContext) +} + +func (s *CreateViewContext) WITH() antlr.TerminalNode { + return s.GetToken(MySqlParserWITH, 0) +} + +func (s *CreateViewContext) CHECK() antlr.TerminalNode { + return s.GetToken(MySqlParserCHECK, 0) +} + +func (s *CreateViewContext) OPTION() antlr.TerminalNode { + return s.GetToken(MySqlParserOPTION, 0) +} + +func (s *CreateViewContext) CASCADED() antlr.TerminalNode { + return s.GetToken(MySqlParserCASCADED, 0) +} + +func (s *CreateViewContext) LOCAL() antlr.TerminalNode { + return s.GetToken(MySqlParserLOCAL, 0) +} + +func (s *CreateViewContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateViewContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateViewContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCreateView(s) + } +} + +func (s *CreateViewContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCreateView(s) + } +} + +func (p *MySqlParser) CreateView() (localctx ICreateViewContext) { + localctx = NewCreateViewContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 56, MySqlParserRULE_createView) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1342) + p.Match(MySqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1344) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserOR { + { + p.SetState(1343) + p.OrReplace() + } + + } + p.SetState(1349) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserALGORITHM { + { + p.SetState(1346) + p.Match(MySqlParserALGORITHM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1347) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1348) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*CreateViewContext).algType = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserMERGE || _la == MySqlParserTEMPTABLE || _la == MySqlParserUNDEFINED) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*CreateViewContext).algType = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(1352) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserDEFINER { + { + p.SetState(1351) + p.OwnerStatement() + } + + } + p.SetState(1357) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserSQL { + { + p.SetState(1354) + p.Match(MySqlParserSQL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1355) + p.Match(MySqlParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1356) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*CreateViewContext).secContext = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserDEFINER || _la == MySqlParserINVOKER) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*CreateViewContext).secContext = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(1359) + p.Match(MySqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1360) + p.FullId() + } + p.SetState(1365) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserLR_BRACKET { + { + p.SetState(1361) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1362) + p.UidList() + } + { + p.SetState(1363) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1367) + p.Match(MySqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1387) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 112, p.GetParserRuleContext()) { + case 1: + { + p.SetState(1368) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1370) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserWITH { + { + p.SetState(1369) + p.WithClause() + } + + } + { + p.SetState(1372) + p.SelectStatement() + } + { + p.SetState(1373) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.SetState(1376) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserWITH { + { + p.SetState(1375) + p.WithClause() + } + + } + { + p.SetState(1378) + p.SelectStatement() + } + p.SetState(1385) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 111, p.GetParserRuleContext()) == 1 { + { + p.SetState(1379) + p.Match(MySqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1381) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserCASCADED || _la == MySqlParserLOCAL { + { + p.SetState(1380) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*CreateViewContext).checkOption = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserCASCADED || _la == MySqlParserLOCAL) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*CreateViewContext).checkOption = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(1383) + p.Match(MySqlParserCHECK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1384) + p.Match(MySqlParserOPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreateDatabaseOptionContext is an interface to support dynamic dispatch. +type ICreateDatabaseOptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CharSet() ICharSetContext + CharsetName() ICharsetNameContext + AllDEFAULT() []antlr.TerminalNode + DEFAULT(i int) antlr.TerminalNode + EQUAL_SYMBOL() antlr.TerminalNode + COLLATE() antlr.TerminalNode + CollationName() ICollationNameContext + ENCRYPTION() antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + READ() antlr.TerminalNode + ONLY() antlr.TerminalNode + ZERO_DECIMAL() antlr.TerminalNode + ONE_DECIMAL() antlr.TerminalNode + + // IsCreateDatabaseOptionContext differentiates from other interfaces. + IsCreateDatabaseOptionContext() +} + +type CreateDatabaseOptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreateDatabaseOptionContext() *CreateDatabaseOptionContext { + var p = new(CreateDatabaseOptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_createDatabaseOption + return p +} + +func InitEmptyCreateDatabaseOptionContext(p *CreateDatabaseOptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_createDatabaseOption +} + +func (*CreateDatabaseOptionContext) IsCreateDatabaseOptionContext() {} + +func NewCreateDatabaseOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateDatabaseOptionContext { + var p = new(CreateDatabaseOptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_createDatabaseOption + + return p +} + +func (s *CreateDatabaseOptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateDatabaseOptionContext) CharSet() ICharSetContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICharSetContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICharSetContext) +} + +func (s *CreateDatabaseOptionContext) CharsetName() ICharsetNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICharsetNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICharsetNameContext) +} + +func (s *CreateDatabaseOptionContext) AllDEFAULT() []antlr.TerminalNode { + return s.GetTokens(MySqlParserDEFAULT) +} + +func (s *CreateDatabaseOptionContext) DEFAULT(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserDEFAULT, i) +} + +func (s *CreateDatabaseOptionContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *CreateDatabaseOptionContext) COLLATE() antlr.TerminalNode { + return s.GetToken(MySqlParserCOLLATE, 0) +} + +func (s *CreateDatabaseOptionContext) CollationName() ICollationNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICollationNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICollationNameContext) +} + +func (s *CreateDatabaseOptionContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(MySqlParserENCRYPTION, 0) +} + +func (s *CreateDatabaseOptionContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *CreateDatabaseOptionContext) READ() antlr.TerminalNode { + return s.GetToken(MySqlParserREAD, 0) +} + +func (s *CreateDatabaseOptionContext) ONLY() antlr.TerminalNode { + return s.GetToken(MySqlParserONLY, 0) +} + +func (s *CreateDatabaseOptionContext) ZERO_DECIMAL() antlr.TerminalNode { + return s.GetToken(MySqlParserZERO_DECIMAL, 0) +} + +func (s *CreateDatabaseOptionContext) ONE_DECIMAL() antlr.TerminalNode { + return s.GetToken(MySqlParserONE_DECIMAL, 0) +} + +func (s *CreateDatabaseOptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateDatabaseOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateDatabaseOptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCreateDatabaseOption(s) + } +} + +func (s *CreateDatabaseOptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCreateDatabaseOption(s) + } +} + +func (p *MySqlParser) CreateDatabaseOption() (localctx ICreateDatabaseOptionContext) { + localctx = NewCreateDatabaseOptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 58, MySqlParserRULE_createDatabaseOption) + var _la int + + p.SetState(1422) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 121, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(1390) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserDEFAULT { + { + p.SetState(1389) + p.Match(MySqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1392) + p.CharSet() + } + p.SetState(1394) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1393) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(1398) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserBINARY, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserCHARSET_REVERSE_QOUTE_STRING, MySqlParserSTRING_LITERAL: + { + p.SetState(1396) + p.CharsetName() + } + + case MySqlParserDEFAULT: + { + p.SetState(1397) + p.Match(MySqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + p.SetState(1401) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserDEFAULT { + { + p.SetState(1400) + p.Match(MySqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1403) + p.Match(MySqlParserCOLLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1405) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1404) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1407) + p.CollationName() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + p.SetState(1409) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserDEFAULT { + { + p.SetState(1408) + p.Match(MySqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1411) + p.Match(MySqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1413) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1412) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1415) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(1416) + p.Match(MySqlParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1417) + p.Match(MySqlParserONLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1419) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1418) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1421) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserDEFAULT || _la == MySqlParserZERO_DECIMAL || _la == MySqlParserONE_DECIMAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICharSetContext is an interface to support dynamic dispatch. +type ICharSetContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHARACTER() antlr.TerminalNode + SET() antlr.TerminalNode + CHARSET() antlr.TerminalNode + CHAR() antlr.TerminalNode + + // IsCharSetContext differentiates from other interfaces. + IsCharSetContext() +} + +type CharSetContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCharSetContext() *CharSetContext { + var p = new(CharSetContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_charSet + return p +} + +func InitEmptyCharSetContext(p *CharSetContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_charSet +} + +func (*CharSetContext) IsCharSetContext() {} + +func NewCharSetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CharSetContext { + var p = new(CharSetContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_charSet + + return p +} + +func (s *CharSetContext) GetParser() antlr.Parser { return s.parser } + +func (s *CharSetContext) CHARACTER() antlr.TerminalNode { + return s.GetToken(MySqlParserCHARACTER, 0) +} + +func (s *CharSetContext) SET() antlr.TerminalNode { + return s.GetToken(MySqlParserSET, 0) +} + +func (s *CharSetContext) CHARSET() antlr.TerminalNode { + return s.GetToken(MySqlParserCHARSET, 0) +} + +func (s *CharSetContext) CHAR() antlr.TerminalNode { + return s.GetToken(MySqlParserCHAR, 0) +} + +func (s *CharSetContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CharSetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CharSetContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCharSet(s) + } +} + +func (s *CharSetContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCharSet(s) + } +} + +func (p *MySqlParser) CharSet() (localctx ICharSetContext) { + localctx = NewCharSetContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 60, MySqlParserRULE_charSet) + p.SetState(1429) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserCHARACTER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1424) + p.Match(MySqlParserCHARACTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1425) + p.Match(MySqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserCHARSET: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1426) + p.Match(MySqlParserCHARSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserCHAR: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1427) + p.Match(MySqlParserCHAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1428) + p.Match(MySqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICurrentUserExpressionContext is an interface to support dynamic dispatch. +type ICurrentUserExpressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CURRENT_USER() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + + // IsCurrentUserExpressionContext differentiates from other interfaces. + IsCurrentUserExpressionContext() +} + +type CurrentUserExpressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCurrentUserExpressionContext() *CurrentUserExpressionContext { + var p = new(CurrentUserExpressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_currentUserExpression + return p +} + +func InitEmptyCurrentUserExpressionContext(p *CurrentUserExpressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_currentUserExpression +} + +func (*CurrentUserExpressionContext) IsCurrentUserExpressionContext() {} + +func NewCurrentUserExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CurrentUserExpressionContext { + var p = new(CurrentUserExpressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_currentUserExpression + + return p +} + +func (s *CurrentUserExpressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *CurrentUserExpressionContext) CURRENT_USER() antlr.TerminalNode { + return s.GetToken(MySqlParserCURRENT_USER, 0) +} + +func (s *CurrentUserExpressionContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *CurrentUserExpressionContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *CurrentUserExpressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CurrentUserExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CurrentUserExpressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCurrentUserExpression(s) + } +} + +func (s *CurrentUserExpressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCurrentUserExpression(s) + } +} + +func (p *MySqlParser) CurrentUserExpression() (localctx ICurrentUserExpressionContext) { + localctx = NewCurrentUserExpressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 62, MySqlParserRULE_currentUserExpression) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1431) + p.Match(MySqlParserCURRENT_USER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1434) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 123, p.GetParserRuleContext()) == 1 { + { + p.SetState(1432) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1433) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOwnerStatementContext is an interface to support dynamic dispatch. +type IOwnerStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DEFINER() antlr.TerminalNode + EQUAL_SYMBOL() antlr.TerminalNode + UserName() IUserNameContext + CurrentUserExpression() ICurrentUserExpressionContext + + // IsOwnerStatementContext differentiates from other interfaces. + IsOwnerStatementContext() +} + +type OwnerStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOwnerStatementContext() *OwnerStatementContext { + var p = new(OwnerStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_ownerStatement + return p +} + +func InitEmptyOwnerStatementContext(p *OwnerStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_ownerStatement +} + +func (*OwnerStatementContext) IsOwnerStatementContext() {} + +func NewOwnerStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OwnerStatementContext { + var p = new(OwnerStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_ownerStatement + + return p +} + +func (s *OwnerStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *OwnerStatementContext) DEFINER() antlr.TerminalNode { + return s.GetToken(MySqlParserDEFINER, 0) +} + +func (s *OwnerStatementContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *OwnerStatementContext) UserName() IUserNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUserNameContext) +} + +func (s *OwnerStatementContext) CurrentUserExpression() ICurrentUserExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICurrentUserExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICurrentUserExpressionContext) +} + +func (s *OwnerStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *OwnerStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *OwnerStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterOwnerStatement(s) + } +} + +func (s *OwnerStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitOwnerStatement(s) + } +} + +func (p *MySqlParser) OwnerStatement() (localctx IOwnerStatementContext) { + localctx = NewOwnerStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 64, MySqlParserRULE_ownerStatement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1436) + p.Match(MySqlParserDEFINER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1437) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1440) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 124, p.GetParserRuleContext()) { + case 1: + { + p.SetState(1438) + p.UserName() + } + + case 2: + { + p.SetState(1439) + p.CurrentUserExpression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IScheduleExpressionContext is an interface to support dynamic dispatch. +type IScheduleExpressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsScheduleExpressionContext differentiates from other interfaces. + IsScheduleExpressionContext() +} + +type ScheduleExpressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyScheduleExpressionContext() *ScheduleExpressionContext { + var p = new(ScheduleExpressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_scheduleExpression + return p +} + +func InitEmptyScheduleExpressionContext(p *ScheduleExpressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_scheduleExpression +} + +func (*ScheduleExpressionContext) IsScheduleExpressionContext() {} + +func NewScheduleExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ScheduleExpressionContext { + var p = new(ScheduleExpressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_scheduleExpression + + return p +} + +func (s *ScheduleExpressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *ScheduleExpressionContext) CopyAll(ctx *ScheduleExpressionContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *ScheduleExpressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ScheduleExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type PreciseScheduleContext struct { + ScheduleExpressionContext +} + +func NewPreciseScheduleContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PreciseScheduleContext { + var p = new(PreciseScheduleContext) + + InitEmptyScheduleExpressionContext(&p.ScheduleExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*ScheduleExpressionContext)) + + return p +} + +func (s *PreciseScheduleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PreciseScheduleContext) AT() antlr.TerminalNode { + return s.GetToken(MySqlParserAT, 0) +} + +func (s *PreciseScheduleContext) TimestampValue() ITimestampValueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITimestampValueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITimestampValueContext) +} + +func (s *PreciseScheduleContext) AllIntervalExpr() []IIntervalExprContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIntervalExprContext); ok { + len++ + } + } + + tst := make([]IIntervalExprContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIntervalExprContext); ok { + tst[i] = t.(IIntervalExprContext) + i++ + } + } + + return tst +} + +func (s *PreciseScheduleContext) IntervalExpr(i int) IIntervalExprContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIntervalExprContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIntervalExprContext) +} + +func (s *PreciseScheduleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterPreciseSchedule(s) + } +} + +func (s *PreciseScheduleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitPreciseSchedule(s) + } +} + +type IntervalScheduleContext struct { + ScheduleExpressionContext + startTimestamp ITimestampValueContext + _intervalExpr IIntervalExprContext + startIntervals []IIntervalExprContext + endTimestamp ITimestampValueContext + endIntervals []IIntervalExprContext +} + +func NewIntervalScheduleContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IntervalScheduleContext { + var p = new(IntervalScheduleContext) + + InitEmptyScheduleExpressionContext(&p.ScheduleExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*ScheduleExpressionContext)) + + return p +} + +func (s *IntervalScheduleContext) GetStartTimestamp() ITimestampValueContext { return s.startTimestamp } + +func (s *IntervalScheduleContext) Get_intervalExpr() IIntervalExprContext { return s._intervalExpr } + +func (s *IntervalScheduleContext) GetEndTimestamp() ITimestampValueContext { return s.endTimestamp } + +func (s *IntervalScheduleContext) SetStartTimestamp(v ITimestampValueContext) { s.startTimestamp = v } + +func (s *IntervalScheduleContext) Set_intervalExpr(v IIntervalExprContext) { s._intervalExpr = v } + +func (s *IntervalScheduleContext) SetEndTimestamp(v ITimestampValueContext) { s.endTimestamp = v } + +func (s *IntervalScheduleContext) GetStartIntervals() []IIntervalExprContext { return s.startIntervals } + +func (s *IntervalScheduleContext) GetEndIntervals() []IIntervalExprContext { return s.endIntervals } + +func (s *IntervalScheduleContext) SetStartIntervals(v []IIntervalExprContext) { s.startIntervals = v } + +func (s *IntervalScheduleContext) SetEndIntervals(v []IIntervalExprContext) { s.endIntervals = v } + +func (s *IntervalScheduleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IntervalScheduleContext) EVERY() antlr.TerminalNode { + return s.GetToken(MySqlParserEVERY, 0) +} + +func (s *IntervalScheduleContext) IntervalType() IIntervalTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIntervalTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIntervalTypeContext) +} + +func (s *IntervalScheduleContext) DecimalLiteral() IDecimalLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *IntervalScheduleContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *IntervalScheduleContext) STARTS() antlr.TerminalNode { + return s.GetToken(MySqlParserSTARTS, 0) +} + +func (s *IntervalScheduleContext) ENDS() antlr.TerminalNode { + return s.GetToken(MySqlParserENDS, 0) +} + +func (s *IntervalScheduleContext) AllTimestampValue() []ITimestampValueContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITimestampValueContext); ok { + len++ + } + } + + tst := make([]ITimestampValueContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITimestampValueContext); ok { + tst[i] = t.(ITimestampValueContext) + i++ + } + } + + return tst +} + +func (s *IntervalScheduleContext) TimestampValue(i int) ITimestampValueContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITimestampValueContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITimestampValueContext) +} + +func (s *IntervalScheduleContext) AllIntervalExpr() []IIntervalExprContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIntervalExprContext); ok { + len++ + } + } + + tst := make([]IIntervalExprContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIntervalExprContext); ok { + tst[i] = t.(IIntervalExprContext) + i++ + } + } + + return tst +} + +func (s *IntervalScheduleContext) IntervalExpr(i int) IIntervalExprContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIntervalExprContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIntervalExprContext) +} + +func (s *IntervalScheduleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterIntervalSchedule(s) + } +} + +func (s *IntervalScheduleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitIntervalSchedule(s) + } +} + +func (p *MySqlParser) ScheduleExpression() (localctx IScheduleExpressionContext) { + localctx = NewScheduleExpressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 66, MySqlParserRULE_scheduleExpression) + var _la int + + p.SetState(1476) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserAT: + localctx = NewPreciseScheduleContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1442) + p.Match(MySqlParserAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1443) + p.TimestampValue() + } + p.SetState(1447) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserPLUS { + { + p.SetState(1444) + p.IntervalExpr() + } + + p.SetState(1449) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case MySqlParserEVERY: + localctx = NewIntervalScheduleContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1450) + p.Match(MySqlParserEVERY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1453) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 126, p.GetParserRuleContext()) { + case 1: + { + p.SetState(1451) + p.DecimalLiteral() + } + + case 2: + { + p.SetState(1452) + p.expression(0) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(1455) + p.IntervalType() + } + p.SetState(1464) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserSTARTS { + { + p.SetState(1456) + p.Match(MySqlParserSTARTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1457) + + var _x = p.TimestampValue() + + localctx.(*IntervalScheduleContext).startTimestamp = _x + } + p.SetState(1461) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserPLUS { + { + p.SetState(1458) + + var _x = p.IntervalExpr() + + localctx.(*IntervalScheduleContext)._intervalExpr = _x + } + localctx.(*IntervalScheduleContext).startIntervals = append(localctx.(*IntervalScheduleContext).startIntervals, localctx.(*IntervalScheduleContext)._intervalExpr) + + p.SetState(1463) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + p.SetState(1474) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserENDS { + { + p.SetState(1466) + p.Match(MySqlParserENDS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1467) + + var _x = p.TimestampValue() + + localctx.(*IntervalScheduleContext).endTimestamp = _x + } + p.SetState(1471) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserPLUS { + { + p.SetState(1468) + + var _x = p.IntervalExpr() + + localctx.(*IntervalScheduleContext)._intervalExpr = _x + } + localctx.(*IntervalScheduleContext).endIntervals = append(localctx.(*IntervalScheduleContext).endIntervals, localctx.(*IntervalScheduleContext)._intervalExpr) + + p.SetState(1473) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITimestampValueContext is an interface to support dynamic dispatch. +type ITimestampValueContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CURRENT_TIMESTAMP() antlr.TerminalNode + StringLiteral() IStringLiteralContext + DecimalLiteral() IDecimalLiteralContext + Expression() IExpressionContext + + // IsTimestampValueContext differentiates from other interfaces. + IsTimestampValueContext() +} + +type TimestampValueContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTimestampValueContext() *TimestampValueContext { + var p = new(TimestampValueContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_timestampValue + return p +} + +func InitEmptyTimestampValueContext(p *TimestampValueContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_timestampValue +} + +func (*TimestampValueContext) IsTimestampValueContext() {} + +func NewTimestampValueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TimestampValueContext { + var p = new(TimestampValueContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_timestampValue + + return p +} + +func (s *TimestampValueContext) GetParser() antlr.Parser { return s.parser } + +func (s *TimestampValueContext) CURRENT_TIMESTAMP() antlr.TerminalNode { + return s.GetToken(MySqlParserCURRENT_TIMESTAMP, 0) +} + +func (s *TimestampValueContext) StringLiteral() IStringLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringLiteralContext) +} + +func (s *TimestampValueContext) DecimalLiteral() IDecimalLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *TimestampValueContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *TimestampValueContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TimestampValueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TimestampValueContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTimestampValue(s) + } +} + +func (s *TimestampValueContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTimestampValue(s) + } +} + +func (p *MySqlParser) TimestampValue() (localctx ITimestampValueContext) { + localctx = NewTimestampValueContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 68, MySqlParserRULE_timestampValue) + p.SetState(1482) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 132, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1478) + p.Match(MySqlParserCURRENT_TIMESTAMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1479) + p.StringLiteral() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1480) + p.DecimalLiteral() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(1481) + p.expression(0) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIntervalExprContext is an interface to support dynamic dispatch. +type IIntervalExprContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PLUS() antlr.TerminalNode + INTERVAL() antlr.TerminalNode + IntervalType() IIntervalTypeContext + DecimalLiteral() IDecimalLiteralContext + Expression() IExpressionContext + + // IsIntervalExprContext differentiates from other interfaces. + IsIntervalExprContext() +} + +type IntervalExprContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIntervalExprContext() *IntervalExprContext { + var p = new(IntervalExprContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_intervalExpr + return p +} + +func InitEmptyIntervalExprContext(p *IntervalExprContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_intervalExpr +} + +func (*IntervalExprContext) IsIntervalExprContext() {} + +func NewIntervalExprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IntervalExprContext { + var p = new(IntervalExprContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_intervalExpr + + return p +} + +func (s *IntervalExprContext) GetParser() antlr.Parser { return s.parser } + +func (s *IntervalExprContext) PLUS() antlr.TerminalNode { + return s.GetToken(MySqlParserPLUS, 0) +} + +func (s *IntervalExprContext) INTERVAL() antlr.TerminalNode { + return s.GetToken(MySqlParserINTERVAL, 0) +} + +func (s *IntervalExprContext) IntervalType() IIntervalTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIntervalTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIntervalTypeContext) +} + +func (s *IntervalExprContext) DecimalLiteral() IDecimalLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *IntervalExprContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *IntervalExprContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IntervalExprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IntervalExprContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterIntervalExpr(s) + } +} + +func (s *IntervalExprContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitIntervalExpr(s) + } +} + +func (p *MySqlParser) IntervalExpr() (localctx IIntervalExprContext) { + localctx = NewIntervalExprContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 70, MySqlParserRULE_intervalExpr) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1484) + p.Match(MySqlParserPLUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1485) + p.Match(MySqlParserINTERVAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1488) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 133, p.GetParserRuleContext()) { + case 1: + { + p.SetState(1486) + p.DecimalLiteral() + } + + case 2: + { + p.SetState(1487) + p.expression(0) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(1490) + p.IntervalType() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIntervalTypeContext is an interface to support dynamic dispatch. +type IIntervalTypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IntervalTypeBase() IIntervalTypeBaseContext + YEAR() antlr.TerminalNode + YEAR_MONTH() antlr.TerminalNode + DAY_HOUR() antlr.TerminalNode + DAY_MINUTE() antlr.TerminalNode + DAY_SECOND() antlr.TerminalNode + HOUR_MINUTE() antlr.TerminalNode + HOUR_SECOND() antlr.TerminalNode + MINUTE_SECOND() antlr.TerminalNode + SECOND_MICROSECOND() antlr.TerminalNode + MINUTE_MICROSECOND() antlr.TerminalNode + HOUR_MICROSECOND() antlr.TerminalNode + DAY_MICROSECOND() antlr.TerminalNode + + // IsIntervalTypeContext differentiates from other interfaces. + IsIntervalTypeContext() +} + +type IntervalTypeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIntervalTypeContext() *IntervalTypeContext { + var p = new(IntervalTypeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_intervalType + return p +} + +func InitEmptyIntervalTypeContext(p *IntervalTypeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_intervalType +} + +func (*IntervalTypeContext) IsIntervalTypeContext() {} + +func NewIntervalTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IntervalTypeContext { + var p = new(IntervalTypeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_intervalType + + return p +} + +func (s *IntervalTypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *IntervalTypeContext) IntervalTypeBase() IIntervalTypeBaseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIntervalTypeBaseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIntervalTypeBaseContext) +} + +func (s *IntervalTypeContext) YEAR() antlr.TerminalNode { + return s.GetToken(MySqlParserYEAR, 0) +} + +func (s *IntervalTypeContext) YEAR_MONTH() antlr.TerminalNode { + return s.GetToken(MySqlParserYEAR_MONTH, 0) +} + +func (s *IntervalTypeContext) DAY_HOUR() antlr.TerminalNode { + return s.GetToken(MySqlParserDAY_HOUR, 0) +} + +func (s *IntervalTypeContext) DAY_MINUTE() antlr.TerminalNode { + return s.GetToken(MySqlParserDAY_MINUTE, 0) +} + +func (s *IntervalTypeContext) DAY_SECOND() antlr.TerminalNode { + return s.GetToken(MySqlParserDAY_SECOND, 0) +} + +func (s *IntervalTypeContext) HOUR_MINUTE() antlr.TerminalNode { + return s.GetToken(MySqlParserHOUR_MINUTE, 0) +} + +func (s *IntervalTypeContext) HOUR_SECOND() antlr.TerminalNode { + return s.GetToken(MySqlParserHOUR_SECOND, 0) +} + +func (s *IntervalTypeContext) MINUTE_SECOND() antlr.TerminalNode { + return s.GetToken(MySqlParserMINUTE_SECOND, 0) +} + +func (s *IntervalTypeContext) SECOND_MICROSECOND() antlr.TerminalNode { + return s.GetToken(MySqlParserSECOND_MICROSECOND, 0) +} + +func (s *IntervalTypeContext) MINUTE_MICROSECOND() antlr.TerminalNode { + return s.GetToken(MySqlParserMINUTE_MICROSECOND, 0) +} + +func (s *IntervalTypeContext) HOUR_MICROSECOND() antlr.TerminalNode { + return s.GetToken(MySqlParserHOUR_MICROSECOND, 0) +} + +func (s *IntervalTypeContext) DAY_MICROSECOND() antlr.TerminalNode { + return s.GetToken(MySqlParserDAY_MICROSECOND, 0) +} + +func (s *IntervalTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IntervalTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IntervalTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterIntervalType(s) + } +} + +func (s *IntervalTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitIntervalType(s) + } +} + +func (p *MySqlParser) IntervalType() (localctx IIntervalTypeContext) { + localctx = NewIntervalTypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 72, MySqlParserRULE_intervalType) + p.SetState(1505) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserQUARTER, MySqlParserMONTH, MySqlParserDAY, MySqlParserHOUR, MySqlParserMINUTE, MySqlParserWEEK, MySqlParserSECOND, MySqlParserMICROSECOND: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1492) + p.IntervalTypeBase() + } + + case MySqlParserYEAR: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1493) + p.Match(MySqlParserYEAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserYEAR_MONTH: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1494) + p.Match(MySqlParserYEAR_MONTH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserDAY_HOUR: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(1495) + p.Match(MySqlParserDAY_HOUR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserDAY_MINUTE: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(1496) + p.Match(MySqlParserDAY_MINUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserDAY_SECOND: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(1497) + p.Match(MySqlParserDAY_SECOND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserHOUR_MINUTE: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(1498) + p.Match(MySqlParserHOUR_MINUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserHOUR_SECOND: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(1499) + p.Match(MySqlParserHOUR_SECOND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserMINUTE_SECOND: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(1500) + p.Match(MySqlParserMINUTE_SECOND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserSECOND_MICROSECOND: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(1501) + p.Match(MySqlParserSECOND_MICROSECOND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserMINUTE_MICROSECOND: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(1502) + p.Match(MySqlParserMINUTE_MICROSECOND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserHOUR_MICROSECOND: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(1503) + p.Match(MySqlParserHOUR_MICROSECOND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserDAY_MICROSECOND: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(1504) + p.Match(MySqlParserDAY_MICROSECOND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IEnableTypeContext is an interface to support dynamic dispatch. +type IEnableTypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ENABLE() antlr.TerminalNode + DISABLE() antlr.TerminalNode + ON() antlr.TerminalNode + SLAVE() antlr.TerminalNode + + // IsEnableTypeContext differentiates from other interfaces. + IsEnableTypeContext() +} + +type EnableTypeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEnableTypeContext() *EnableTypeContext { + var p = new(EnableTypeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_enableType + return p +} + +func InitEmptyEnableTypeContext(p *EnableTypeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_enableType +} + +func (*EnableTypeContext) IsEnableTypeContext() {} + +func NewEnableTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnableTypeContext { + var p = new(EnableTypeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_enableType + + return p +} + +func (s *EnableTypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *EnableTypeContext) ENABLE() antlr.TerminalNode { + return s.GetToken(MySqlParserENABLE, 0) +} + +func (s *EnableTypeContext) DISABLE() antlr.TerminalNode { + return s.GetToken(MySqlParserDISABLE, 0) +} + +func (s *EnableTypeContext) ON() antlr.TerminalNode { + return s.GetToken(MySqlParserON, 0) +} + +func (s *EnableTypeContext) SLAVE() antlr.TerminalNode { + return s.GetToken(MySqlParserSLAVE, 0) +} + +func (s *EnableTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *EnableTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *EnableTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterEnableType(s) + } +} + +func (s *EnableTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitEnableType(s) + } +} + +func (p *MySqlParser) EnableType() (localctx IEnableTypeContext) { + localctx = NewEnableTypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 74, MySqlParserRULE_enableType) + p.SetState(1512) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 135, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1507) + p.Match(MySqlParserENABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1508) + p.Match(MySqlParserDISABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1509) + p.Match(MySqlParserDISABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1510) + p.Match(MySqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1511) + p.Match(MySqlParserSLAVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndexTypeContext is an interface to support dynamic dispatch. +type IIndexTypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + USING() antlr.TerminalNode + BTREE() antlr.TerminalNode + HASH() antlr.TerminalNode + + // IsIndexTypeContext differentiates from other interfaces. + IsIndexTypeContext() +} + +type IndexTypeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndexTypeContext() *IndexTypeContext { + var p = new(IndexTypeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_indexType + return p +} + +func InitEmptyIndexTypeContext(p *IndexTypeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_indexType +} + +func (*IndexTypeContext) IsIndexTypeContext() {} + +func NewIndexTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndexTypeContext { + var p = new(IndexTypeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_indexType + + return p +} + +func (s *IndexTypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *IndexTypeContext) USING() antlr.TerminalNode { + return s.GetToken(MySqlParserUSING, 0) +} + +func (s *IndexTypeContext) BTREE() antlr.TerminalNode { + return s.GetToken(MySqlParserBTREE, 0) +} + +func (s *IndexTypeContext) HASH() antlr.TerminalNode { + return s.GetToken(MySqlParserHASH, 0) +} + +func (s *IndexTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IndexTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IndexTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterIndexType(s) + } +} + +func (s *IndexTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitIndexType(s) + } +} + +func (p *MySqlParser) IndexType() (localctx IIndexTypeContext) { + localctx = NewIndexTypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 76, MySqlParserRULE_indexType) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1514) + p.Match(MySqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1515) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserBTREE || _la == MySqlParserHASH) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndexOptionContext is an interface to support dynamic dispatch. +type IIndexOptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KEY_BLOCK_SIZE() antlr.TerminalNode + FileSizeLiteral() IFileSizeLiteralContext + EQUAL_SYMBOL() antlr.TerminalNode + IndexType() IIndexTypeContext + WITH() antlr.TerminalNode + PARSER() antlr.TerminalNode + Uid() IUidContext + COMMENT() antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + VISIBLE() antlr.TerminalNode + INVISIBLE() antlr.TerminalNode + ENGINE_ATTRIBUTE() antlr.TerminalNode + SECONDARY_ENGINE_ATTRIBUTE() antlr.TerminalNode + + // IsIndexOptionContext differentiates from other interfaces. + IsIndexOptionContext() +} + +type IndexOptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndexOptionContext() *IndexOptionContext { + var p = new(IndexOptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_indexOption + return p +} + +func InitEmptyIndexOptionContext(p *IndexOptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_indexOption +} + +func (*IndexOptionContext) IsIndexOptionContext() {} + +func NewIndexOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndexOptionContext { + var p = new(IndexOptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_indexOption + + return p +} + +func (s *IndexOptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *IndexOptionContext) KEY_BLOCK_SIZE() antlr.TerminalNode { + return s.GetToken(MySqlParserKEY_BLOCK_SIZE, 0) +} + +func (s *IndexOptionContext) FileSizeLiteral() IFileSizeLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFileSizeLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFileSizeLiteralContext) +} + +func (s *IndexOptionContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *IndexOptionContext) IndexType() IIndexTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndexTypeContext) +} + +func (s *IndexOptionContext) WITH() antlr.TerminalNode { + return s.GetToken(MySqlParserWITH, 0) +} + +func (s *IndexOptionContext) PARSER() antlr.TerminalNode { + return s.GetToken(MySqlParserPARSER, 0) +} + +func (s *IndexOptionContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *IndexOptionContext) COMMENT() antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMENT, 0) +} + +func (s *IndexOptionContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *IndexOptionContext) VISIBLE() antlr.TerminalNode { + return s.GetToken(MySqlParserVISIBLE, 0) +} + +func (s *IndexOptionContext) INVISIBLE() antlr.TerminalNode { + return s.GetToken(MySqlParserINVISIBLE, 0) +} + +func (s *IndexOptionContext) ENGINE_ATTRIBUTE() antlr.TerminalNode { + return s.GetToken(MySqlParserENGINE_ATTRIBUTE, 0) +} + +func (s *IndexOptionContext) SECONDARY_ENGINE_ATTRIBUTE() antlr.TerminalNode { + return s.GetToken(MySqlParserSECONDARY_ENGINE_ATTRIBUTE, 0) +} + +func (s *IndexOptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IndexOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IndexOptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterIndexOption(s) + } +} + +func (s *IndexOptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitIndexOption(s) + } +} + +func (p *MySqlParser) IndexOption() (localctx IIndexOptionContext) { + localctx = NewIndexOptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 78, MySqlParserRULE_indexOption) + var _la int + + p.SetState(1539) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserKEY_BLOCK_SIZE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1517) + p.Match(MySqlParserKEY_BLOCK_SIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1519) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1518) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1521) + p.FileSizeLiteral() + } + + case MySqlParserUSING: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1522) + p.IndexType() + } + + case MySqlParserWITH: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1523) + p.Match(MySqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1524) + p.Match(MySqlParserPARSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1525) + p.Uid() + } + + case MySqlParserCOMMENT: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(1526) + p.Match(MySqlParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1527) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserINVISIBLE, MySqlParserVISIBLE: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(1528) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserINVISIBLE || _la == MySqlParserVISIBLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case MySqlParserENGINE_ATTRIBUTE: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(1529) + p.Match(MySqlParserENGINE_ATTRIBUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1531) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1530) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1533) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserSECONDARY_ENGINE_ATTRIBUTE: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(1534) + p.Match(MySqlParserSECONDARY_ENGINE_ATTRIBUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1536) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1535) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1538) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IProcedureParameterContext is an interface to support dynamic dispatch. +type IProcedureParameterContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetDirection returns the direction token. + GetDirection() antlr.Token + + // SetDirection sets the direction token. + SetDirection(antlr.Token) + + // Getter signatures + Uid() IUidContext + DataType() IDataTypeContext + IN() antlr.TerminalNode + OUT() antlr.TerminalNode + INOUT() antlr.TerminalNode + + // IsProcedureParameterContext differentiates from other interfaces. + IsProcedureParameterContext() +} + +type ProcedureParameterContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + direction antlr.Token +} + +func NewEmptyProcedureParameterContext() *ProcedureParameterContext { + var p = new(ProcedureParameterContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_procedureParameter + return p +} + +func InitEmptyProcedureParameterContext(p *ProcedureParameterContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_procedureParameter +} + +func (*ProcedureParameterContext) IsProcedureParameterContext() {} + +func NewProcedureParameterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ProcedureParameterContext { + var p = new(ProcedureParameterContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_procedureParameter + + return p +} + +func (s *ProcedureParameterContext) GetParser() antlr.Parser { return s.parser } + +func (s *ProcedureParameterContext) GetDirection() antlr.Token { return s.direction } + +func (s *ProcedureParameterContext) SetDirection(v antlr.Token) { s.direction = v } + +func (s *ProcedureParameterContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *ProcedureParameterContext) DataType() IDataTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDataTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDataTypeContext) +} + +func (s *ProcedureParameterContext) IN() antlr.TerminalNode { + return s.GetToken(MySqlParserIN, 0) +} + +func (s *ProcedureParameterContext) OUT() antlr.TerminalNode { + return s.GetToken(MySqlParserOUT, 0) +} + +func (s *ProcedureParameterContext) INOUT() antlr.TerminalNode { + return s.GetToken(MySqlParserINOUT, 0) +} + +func (s *ProcedureParameterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ProcedureParameterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ProcedureParameterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterProcedureParameter(s) + } +} + +func (s *ProcedureParameterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitProcedureParameter(s) + } +} + +func (p *MySqlParser) ProcedureParameter() (localctx IProcedureParameterContext) { + localctx = NewProcedureParameterContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 80, MySqlParserRULE_procedureParameter) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(1542) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if (int64((_la-80)) & ^0x3f) == 0 && ((int64(1)<<(_la-80))&35184372088849) != 0 { + { + p.SetState(1541) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*ProcedureParameterContext).direction = _lt + + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-80)) & ^0x3f) == 0 && ((int64(1)<<(_la-80))&35184372088849) != 0) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*ProcedureParameterContext).direction = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(1544) + p.Uid() + } + { + p.SetState(1545) + p.DataType() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunctionParameterContext is an interface to support dynamic dispatch. +type IFunctionParameterContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Uid() IUidContext + DataType() IDataTypeContext + + // IsFunctionParameterContext differentiates from other interfaces. + IsFunctionParameterContext() +} + +type FunctionParameterContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunctionParameterContext() *FunctionParameterContext { + var p = new(FunctionParameterContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_functionParameter + return p +} + +func InitEmptyFunctionParameterContext(p *FunctionParameterContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_functionParameter +} + +func (*FunctionParameterContext) IsFunctionParameterContext() {} + +func NewFunctionParameterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionParameterContext { + var p = new(FunctionParameterContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_functionParameter + + return p +} + +func (s *FunctionParameterContext) GetParser() antlr.Parser { return s.parser } + +func (s *FunctionParameterContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *FunctionParameterContext) DataType() IDataTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDataTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDataTypeContext) +} + +func (s *FunctionParameterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FunctionParameterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FunctionParameterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterFunctionParameter(s) + } +} + +func (s *FunctionParameterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitFunctionParameter(s) + } +} + +func (p *MySqlParser) FunctionParameter() (localctx IFunctionParameterContext) { + localctx = NewFunctionParameterContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 82, MySqlParserRULE_functionParameter) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1547) + p.Uid() + } + { + p.SetState(1548) + p.DataType() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRoutineOptionContext is an interface to support dynamic dispatch. +type IRoutineOptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsRoutineOptionContext differentiates from other interfaces. + IsRoutineOptionContext() +} + +type RoutineOptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRoutineOptionContext() *RoutineOptionContext { + var p = new(RoutineOptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_routineOption + return p +} + +func InitEmptyRoutineOptionContext(p *RoutineOptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_routineOption +} + +func (*RoutineOptionContext) IsRoutineOptionContext() {} + +func NewRoutineOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RoutineOptionContext { + var p = new(RoutineOptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_routineOption + + return p +} + +func (s *RoutineOptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *RoutineOptionContext) CopyAll(ctx *RoutineOptionContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *RoutineOptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RoutineOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type RoutineBehaviorContext struct { + RoutineOptionContext +} + +func NewRoutineBehaviorContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RoutineBehaviorContext { + var p = new(RoutineBehaviorContext) + + InitEmptyRoutineOptionContext(&p.RoutineOptionContext) + p.parser = parser + p.CopyAll(ctx.(*RoutineOptionContext)) + + return p +} + +func (s *RoutineBehaviorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RoutineBehaviorContext) DETERMINISTIC() antlr.TerminalNode { + return s.GetToken(MySqlParserDETERMINISTIC, 0) +} + +func (s *RoutineBehaviorContext) NOT() antlr.TerminalNode { + return s.GetToken(MySqlParserNOT, 0) +} + +func (s *RoutineBehaviorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterRoutineBehavior(s) + } +} + +func (s *RoutineBehaviorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitRoutineBehavior(s) + } +} + +type RoutineLanguageContext struct { + RoutineOptionContext +} + +func NewRoutineLanguageContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RoutineLanguageContext { + var p = new(RoutineLanguageContext) + + InitEmptyRoutineOptionContext(&p.RoutineOptionContext) + p.parser = parser + p.CopyAll(ctx.(*RoutineOptionContext)) + + return p +} + +func (s *RoutineLanguageContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RoutineLanguageContext) LANGUAGE() antlr.TerminalNode { + return s.GetToken(MySqlParserLANGUAGE, 0) +} + +func (s *RoutineLanguageContext) SQL() antlr.TerminalNode { + return s.GetToken(MySqlParserSQL, 0) +} + +func (s *RoutineLanguageContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterRoutineLanguage(s) + } +} + +func (s *RoutineLanguageContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitRoutineLanguage(s) + } +} + +type RoutineCommentContext struct { + RoutineOptionContext +} + +func NewRoutineCommentContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RoutineCommentContext { + var p = new(RoutineCommentContext) + + InitEmptyRoutineOptionContext(&p.RoutineOptionContext) + p.parser = parser + p.CopyAll(ctx.(*RoutineOptionContext)) + + return p +} + +func (s *RoutineCommentContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RoutineCommentContext) COMMENT() antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMENT, 0) +} + +func (s *RoutineCommentContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *RoutineCommentContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterRoutineComment(s) + } +} + +func (s *RoutineCommentContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitRoutineComment(s) + } +} + +type RoutineSecurityContext struct { + RoutineOptionContext + context antlr.Token +} + +func NewRoutineSecurityContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RoutineSecurityContext { + var p = new(RoutineSecurityContext) + + InitEmptyRoutineOptionContext(&p.RoutineOptionContext) + p.parser = parser + p.CopyAll(ctx.(*RoutineOptionContext)) + + return p +} + +func (s *RoutineSecurityContext) GetContext() antlr.Token { return s.context } + +func (s *RoutineSecurityContext) SetContext(v antlr.Token) { s.context = v } + +func (s *RoutineSecurityContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RoutineSecurityContext) SQL() antlr.TerminalNode { + return s.GetToken(MySqlParserSQL, 0) +} + +func (s *RoutineSecurityContext) SECURITY() antlr.TerminalNode { + return s.GetToken(MySqlParserSECURITY, 0) +} + +func (s *RoutineSecurityContext) DEFINER() antlr.TerminalNode { + return s.GetToken(MySqlParserDEFINER, 0) +} + +func (s *RoutineSecurityContext) INVOKER() antlr.TerminalNode { + return s.GetToken(MySqlParserINVOKER, 0) +} + +func (s *RoutineSecurityContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterRoutineSecurity(s) + } +} + +func (s *RoutineSecurityContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitRoutineSecurity(s) + } +} + +type RoutineDataContext struct { + RoutineOptionContext +} + +func NewRoutineDataContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RoutineDataContext { + var p = new(RoutineDataContext) + + InitEmptyRoutineOptionContext(&p.RoutineOptionContext) + p.parser = parser + p.CopyAll(ctx.(*RoutineOptionContext)) + + return p +} + +func (s *RoutineDataContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RoutineDataContext) CONTAINS() antlr.TerminalNode { + return s.GetToken(MySqlParserCONTAINS, 0) +} + +func (s *RoutineDataContext) SQL() antlr.TerminalNode { + return s.GetToken(MySqlParserSQL, 0) +} + +func (s *RoutineDataContext) NO() antlr.TerminalNode { + return s.GetToken(MySqlParserNO, 0) +} + +func (s *RoutineDataContext) READS() antlr.TerminalNode { + return s.GetToken(MySqlParserREADS, 0) +} + +func (s *RoutineDataContext) DATA() antlr.TerminalNode { + return s.GetToken(MySqlParserDATA, 0) +} + +func (s *RoutineDataContext) MODIFIES() antlr.TerminalNode { + return s.GetToken(MySqlParserMODIFIES, 0) +} + +func (s *RoutineDataContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterRoutineData(s) + } +} + +func (s *RoutineDataContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitRoutineData(s) + } +} + +func (p *MySqlParser) RoutineOption() (localctx IRoutineOptionContext) { + localctx = NewRoutineOptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 84, MySqlParserRULE_routineOption) + var _la int + + p.SetState(1573) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserCOMMENT: + localctx = NewRoutineCommentContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1550) + p.Match(MySqlParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1551) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserLANGUAGE: + localctx = NewRoutineLanguageContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1552) + p.Match(MySqlParserLANGUAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1553) + p.Match(MySqlParserSQL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserDETERMINISTIC, MySqlParserNOT: + localctx = NewRoutineBehaviorContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + p.SetState(1555) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserNOT { + { + p.SetState(1554) + p.Match(MySqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1557) + p.Match(MySqlParserDETERMINISTIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserMODIFIES, MySqlParserREADS, MySqlParserCONTAINS, MySqlParserNO: + localctx = NewRoutineDataContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + p.SetState(1568) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserCONTAINS: + { + p.SetState(1558) + p.Match(MySqlParserCONTAINS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1559) + p.Match(MySqlParserSQL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserNO: + { + p.SetState(1560) + p.Match(MySqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1561) + p.Match(MySqlParserSQL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserREADS: + { + p.SetState(1562) + p.Match(MySqlParserREADS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1563) + p.Match(MySqlParserSQL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1564) + p.Match(MySqlParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserMODIFIES: + { + p.SetState(1565) + p.Match(MySqlParserMODIFIES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1566) + p.Match(MySqlParserSQL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1567) + p.Match(MySqlParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case MySqlParserSQL: + localctx = NewRoutineSecurityContext(p, localctx) + p.EnterOuterAlt(localctx, 5) + { + p.SetState(1570) + p.Match(MySqlParserSQL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1571) + p.Match(MySqlParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1572) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*RoutineSecurityContext).context = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserDEFINER || _la == MySqlParserINVOKER) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*RoutineSecurityContext).context = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IServerOptionContext is an interface to support dynamic dispatch. +type IServerOptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + HOST() antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + DATABASE() antlr.TerminalNode + USER() antlr.TerminalNode + PASSWORD() antlr.TerminalNode + SOCKET() antlr.TerminalNode + OWNER() antlr.TerminalNode + PORT() antlr.TerminalNode + DecimalLiteral() IDecimalLiteralContext + + // IsServerOptionContext differentiates from other interfaces. + IsServerOptionContext() +} + +type ServerOptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyServerOptionContext() *ServerOptionContext { + var p = new(ServerOptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_serverOption + return p +} + +func InitEmptyServerOptionContext(p *ServerOptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_serverOption +} + +func (*ServerOptionContext) IsServerOptionContext() {} + +func NewServerOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ServerOptionContext { + var p = new(ServerOptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_serverOption + + return p +} + +func (s *ServerOptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *ServerOptionContext) HOST() antlr.TerminalNode { + return s.GetToken(MySqlParserHOST, 0) +} + +func (s *ServerOptionContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *ServerOptionContext) DATABASE() antlr.TerminalNode { + return s.GetToken(MySqlParserDATABASE, 0) +} + +func (s *ServerOptionContext) USER() antlr.TerminalNode { + return s.GetToken(MySqlParserUSER, 0) +} + +func (s *ServerOptionContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(MySqlParserPASSWORD, 0) +} + +func (s *ServerOptionContext) SOCKET() antlr.TerminalNode { + return s.GetToken(MySqlParserSOCKET, 0) +} + +func (s *ServerOptionContext) OWNER() antlr.TerminalNode { + return s.GetToken(MySqlParserOWNER, 0) +} + +func (s *ServerOptionContext) PORT() antlr.TerminalNode { + return s.GetToken(MySqlParserPORT, 0) +} + +func (s *ServerOptionContext) DecimalLiteral() IDecimalLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *ServerOptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ServerOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ServerOptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterServerOption(s) + } +} + +func (s *ServerOptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitServerOption(s) + } +} + +func (p *MySqlParser) ServerOption() (localctx IServerOptionContext) { + localctx = NewServerOptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 86, MySqlParserRULE_serverOption) + p.SetState(1589) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserHOST: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1575) + p.Match(MySqlParserHOST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1576) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserDATABASE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1577) + p.Match(MySqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1578) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserUSER: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1579) + p.Match(MySqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1580) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserPASSWORD: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(1581) + p.Match(MySqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1582) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserSOCKET: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(1583) + p.Match(MySqlParserSOCKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1584) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserOWNER: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(1585) + p.Match(MySqlParserOWNER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1586) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserPORT: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(1587) + p.Match(MySqlParserPORT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1588) + p.DecimalLiteral() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreateDefinitionsContext is an interface to support dynamic dispatch. +type ICreateDefinitionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + AllCreateDefinition() []ICreateDefinitionContext + CreateDefinition(i int) ICreateDefinitionContext + RR_BRACKET() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsCreateDefinitionsContext differentiates from other interfaces. + IsCreateDefinitionsContext() +} + +type CreateDefinitionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreateDefinitionsContext() *CreateDefinitionsContext { + var p = new(CreateDefinitionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_createDefinitions + return p +} + +func InitEmptyCreateDefinitionsContext(p *CreateDefinitionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_createDefinitions +} + +func (*CreateDefinitionsContext) IsCreateDefinitionsContext() {} + +func NewCreateDefinitionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateDefinitionsContext { + var p = new(CreateDefinitionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_createDefinitions + + return p +} + +func (s *CreateDefinitionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateDefinitionsContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *CreateDefinitionsContext) AllCreateDefinition() []ICreateDefinitionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICreateDefinitionContext); ok { + len++ + } + } + + tst := make([]ICreateDefinitionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICreateDefinitionContext); ok { + tst[i] = t.(ICreateDefinitionContext) + i++ + } + } + + return tst +} + +func (s *CreateDefinitionsContext) CreateDefinition(i int) ICreateDefinitionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateDefinitionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICreateDefinitionContext) +} + +func (s *CreateDefinitionsContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *CreateDefinitionsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *CreateDefinitionsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *CreateDefinitionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateDefinitionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateDefinitionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCreateDefinitions(s) + } +} + +func (s *CreateDefinitionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCreateDefinitions(s) + } +} + +func (p *MySqlParser) CreateDefinitions() (localctx ICreateDefinitionsContext) { + localctx = NewCreateDefinitionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 88, MySqlParserRULE_createDefinitions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1591) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1592) + p.CreateDefinition() + } + p.SetState(1597) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(1593) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1594) + p.CreateDefinition() + } + + p.SetState(1599) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1600) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreateDefinitionContext is an interface to support dynamic dispatch. +type ICreateDefinitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsCreateDefinitionContext differentiates from other interfaces. + IsCreateDefinitionContext() +} + +type CreateDefinitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreateDefinitionContext() *CreateDefinitionContext { + var p = new(CreateDefinitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_createDefinition + return p +} + +func InitEmptyCreateDefinitionContext(p *CreateDefinitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_createDefinition +} + +func (*CreateDefinitionContext) IsCreateDefinitionContext() {} + +func NewCreateDefinitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateDefinitionContext { + var p = new(CreateDefinitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_createDefinition + + return p +} + +func (s *CreateDefinitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateDefinitionContext) CopyAll(ctx *CreateDefinitionContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *CreateDefinitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateDefinitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type ColumnDeclarationContext struct { + CreateDefinitionContext +} + +func NewColumnDeclarationContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ColumnDeclarationContext { + var p = new(ColumnDeclarationContext) + + InitEmptyCreateDefinitionContext(&p.CreateDefinitionContext) + p.parser = parser + p.CopyAll(ctx.(*CreateDefinitionContext)) + + return p +} + +func (s *ColumnDeclarationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ColumnDeclarationContext) FullColumnName() IFullColumnNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFullColumnNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFullColumnNameContext) +} + +func (s *ColumnDeclarationContext) ColumnDefinition() IColumnDefinitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnDefinitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnDefinitionContext) +} + +func (s *ColumnDeclarationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterColumnDeclaration(s) + } +} + +func (s *ColumnDeclarationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitColumnDeclaration(s) + } +} + +type ConstraintDeclarationContext struct { + CreateDefinitionContext +} + +func NewConstraintDeclarationContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ConstraintDeclarationContext { + var p = new(ConstraintDeclarationContext) + + InitEmptyCreateDefinitionContext(&p.CreateDefinitionContext) + p.parser = parser + p.CopyAll(ctx.(*CreateDefinitionContext)) + + return p +} + +func (s *ConstraintDeclarationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ConstraintDeclarationContext) TableConstraint() ITableConstraintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableConstraintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableConstraintContext) +} + +func (s *ConstraintDeclarationContext) NOT() antlr.TerminalNode { + return s.GetToken(MySqlParserNOT, 0) +} + +func (s *ConstraintDeclarationContext) ENFORCED() antlr.TerminalNode { + return s.GetToken(MySqlParserENFORCED, 0) +} + +func (s *ConstraintDeclarationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterConstraintDeclaration(s) + } +} + +func (s *ConstraintDeclarationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitConstraintDeclaration(s) + } +} + +type IndexDeclarationContext struct { + CreateDefinitionContext +} + +func NewIndexDeclarationContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IndexDeclarationContext { + var p = new(IndexDeclarationContext) + + InitEmptyCreateDefinitionContext(&p.CreateDefinitionContext) + p.parser = parser + p.CopyAll(ctx.(*CreateDefinitionContext)) + + return p +} + +func (s *IndexDeclarationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IndexDeclarationContext) IndexColumnDefinition() IIndexColumnDefinitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexColumnDefinitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndexColumnDefinitionContext) +} + +func (s *IndexDeclarationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterIndexDeclaration(s) + } +} + +func (s *IndexDeclarationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitIndexDeclaration(s) + } +} + +func (p *MySqlParser) CreateDefinition() (localctx ICreateDefinitionContext) { + localctx = NewCreateDefinitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 90, MySqlParserRULE_createDefinition) + var _la int + + p.SetState(1613) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 148, p.GetParserRuleContext()) { + case 1: + localctx = NewColumnDeclarationContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1602) + p.FullColumnName() + } + { + p.SetState(1603) + p.ColumnDefinition() + } + + case 2: + localctx = NewConstraintDeclarationContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1605) + p.TableConstraint() + } + p.SetState(1607) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserNOT { + { + p.SetState(1606) + p.Match(MySqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(1610) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserENFORCED { + { + p.SetState(1609) + p.Match(MySqlParserENFORCED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 3: + localctx = NewIndexDeclarationContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1612) + p.IndexColumnDefinition() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumnDefinitionContext is an interface to support dynamic dispatch. +type IColumnDefinitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DataType() IDataTypeContext + AllColumnConstraint() []IColumnConstraintContext + ColumnConstraint(i int) IColumnConstraintContext + NOT() antlr.TerminalNode + ENFORCED() antlr.TerminalNode + + // IsColumnDefinitionContext differentiates from other interfaces. + IsColumnDefinitionContext() +} + +type ColumnDefinitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumnDefinitionContext() *ColumnDefinitionContext { + var p = new(ColumnDefinitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_columnDefinition + return p +} + +func InitEmptyColumnDefinitionContext(p *ColumnDefinitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_columnDefinition +} + +func (*ColumnDefinitionContext) IsColumnDefinitionContext() {} + +func NewColumnDefinitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColumnDefinitionContext { + var p = new(ColumnDefinitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_columnDefinition + + return p +} + +func (s *ColumnDefinitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *ColumnDefinitionContext) DataType() IDataTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDataTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDataTypeContext) +} + +func (s *ColumnDefinitionContext) AllColumnConstraint() []IColumnConstraintContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumnConstraintContext); ok { + len++ + } + } + + tst := make([]IColumnConstraintContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumnConstraintContext); ok { + tst[i] = t.(IColumnConstraintContext) + i++ + } + } + + return tst +} + +func (s *ColumnDefinitionContext) ColumnConstraint(i int) IColumnConstraintContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnConstraintContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumnConstraintContext) +} + +func (s *ColumnDefinitionContext) NOT() antlr.TerminalNode { + return s.GetToken(MySqlParserNOT, 0) +} + +func (s *ColumnDefinitionContext) ENFORCED() antlr.TerminalNode { + return s.GetToken(MySqlParserENFORCED, 0) +} + +func (s *ColumnDefinitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ColumnDefinitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ColumnDefinitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterColumnDefinition(s) + } +} + +func (s *ColumnDefinitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitColumnDefinition(s) + } +} + +func (p *MySqlParser) ColumnDefinition() (localctx IColumnDefinitionContext) { + localctx = NewColumnDefinitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 92, MySqlParserRULE_columnDefinition) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1615) + p.DataType() + } + p.SetState(1619) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 149, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(1616) + p.ColumnConstraint() + } + + } + p.SetState(1621) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 149, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(1623) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserNOT { + { + p.SetState(1622) + p.Match(MySqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(1626) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserENFORCED { + { + p.SetState(1625) + p.Match(MySqlParserENFORCED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumnConstraintContext is an interface to support dynamic dispatch. +type IColumnConstraintContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsColumnConstraintContext differentiates from other interfaces. + IsColumnConstraintContext() +} + +type ColumnConstraintContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumnConstraintContext() *ColumnConstraintContext { + var p = new(ColumnConstraintContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_columnConstraint + return p +} + +func InitEmptyColumnConstraintContext(p *ColumnConstraintContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_columnConstraint +} + +func (*ColumnConstraintContext) IsColumnConstraintContext() {} + +func NewColumnConstraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColumnConstraintContext { + var p = new(ColumnConstraintContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_columnConstraint + + return p +} + +func (s *ColumnConstraintContext) GetParser() antlr.Parser { return s.parser } + +func (s *ColumnConstraintContext) CopyAll(ctx *ColumnConstraintContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *ColumnConstraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ColumnConstraintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type StorageColumnConstraintContext struct { + ColumnConstraintContext + storageval antlr.Token +} + +func NewStorageColumnConstraintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StorageColumnConstraintContext { + var p = new(StorageColumnConstraintContext) + + InitEmptyColumnConstraintContext(&p.ColumnConstraintContext) + p.parser = parser + p.CopyAll(ctx.(*ColumnConstraintContext)) + + return p +} + +func (s *StorageColumnConstraintContext) GetStorageval() antlr.Token { return s.storageval } + +func (s *StorageColumnConstraintContext) SetStorageval(v antlr.Token) { s.storageval = v } + +func (s *StorageColumnConstraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *StorageColumnConstraintContext) STORAGE() antlr.TerminalNode { + return s.GetToken(MySqlParserSTORAGE, 0) +} + +func (s *StorageColumnConstraintContext) DISK() antlr.TerminalNode { + return s.GetToken(MySqlParserDISK, 0) +} + +func (s *StorageColumnConstraintContext) MEMORY() antlr.TerminalNode { + return s.GetToken(MySqlParserMEMORY, 0) +} + +func (s *StorageColumnConstraintContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(MySqlParserDEFAULT, 0) +} + +func (s *StorageColumnConstraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterStorageColumnConstraint(s) + } +} + +func (s *StorageColumnConstraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitStorageColumnConstraint(s) + } +} + +type VisibilityColumnConstraintContext struct { + ColumnConstraintContext +} + +func NewVisibilityColumnConstraintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *VisibilityColumnConstraintContext { + var p = new(VisibilityColumnConstraintContext) + + InitEmptyColumnConstraintContext(&p.ColumnConstraintContext) + p.parser = parser + p.CopyAll(ctx.(*ColumnConstraintContext)) + + return p +} + +func (s *VisibilityColumnConstraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *VisibilityColumnConstraintContext) VISIBLE() antlr.TerminalNode { + return s.GetToken(MySqlParserVISIBLE, 0) +} + +func (s *VisibilityColumnConstraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterVisibilityColumnConstraint(s) + } +} + +func (s *VisibilityColumnConstraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitVisibilityColumnConstraint(s) + } +} + +type AutoIncrementColumnConstraintContext struct { + ColumnConstraintContext +} + +func NewAutoIncrementColumnConstraintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AutoIncrementColumnConstraintContext { + var p = new(AutoIncrementColumnConstraintContext) + + InitEmptyColumnConstraintContext(&p.ColumnConstraintContext) + p.parser = parser + p.CopyAll(ctx.(*ColumnConstraintContext)) + + return p +} + +func (s *AutoIncrementColumnConstraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AutoIncrementColumnConstraintContext) AUTO_INCREMENT() antlr.TerminalNode { + return s.GetToken(MySqlParserAUTO_INCREMENT, 0) +} + +func (s *AutoIncrementColumnConstraintContext) ON() antlr.TerminalNode { + return s.GetToken(MySqlParserON, 0) +} + +func (s *AutoIncrementColumnConstraintContext) UPDATE() antlr.TerminalNode { + return s.GetToken(MySqlParserUPDATE, 0) +} + +func (s *AutoIncrementColumnConstraintContext) CurrentTimestamp() ICurrentTimestampContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICurrentTimestampContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICurrentTimestampContext) +} + +func (s *AutoIncrementColumnConstraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAutoIncrementColumnConstraint(s) + } +} + +func (s *AutoIncrementColumnConstraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAutoIncrementColumnConstraint(s) + } +} + +type CommentColumnConstraintContext struct { + ColumnConstraintContext +} + +func NewCommentColumnConstraintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CommentColumnConstraintContext { + var p = new(CommentColumnConstraintContext) + + InitEmptyColumnConstraintContext(&p.ColumnConstraintContext) + p.parser = parser + p.CopyAll(ctx.(*ColumnConstraintContext)) + + return p +} + +func (s *CommentColumnConstraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CommentColumnConstraintContext) COMMENT() antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMENT, 0) +} + +func (s *CommentColumnConstraintContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *CommentColumnConstraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCommentColumnConstraint(s) + } +} + +func (s *CommentColumnConstraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCommentColumnConstraint(s) + } +} + +type UniqueKeyColumnConstraintContext struct { + ColumnConstraintContext +} + +func NewUniqueKeyColumnConstraintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *UniqueKeyColumnConstraintContext { + var p = new(UniqueKeyColumnConstraintContext) + + InitEmptyColumnConstraintContext(&p.ColumnConstraintContext) + p.parser = parser + p.CopyAll(ctx.(*ColumnConstraintContext)) + + return p +} + +func (s *UniqueKeyColumnConstraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UniqueKeyColumnConstraintContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(MySqlParserUNIQUE, 0) +} + +func (s *UniqueKeyColumnConstraintContext) KEY() antlr.TerminalNode { + return s.GetToken(MySqlParserKEY, 0) +} + +func (s *UniqueKeyColumnConstraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterUniqueKeyColumnConstraint(s) + } +} + +func (s *UniqueKeyColumnConstraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitUniqueKeyColumnConstraint(s) + } +} + +type SerialDefaultColumnConstraintContext struct { + ColumnConstraintContext +} + +func NewSerialDefaultColumnConstraintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SerialDefaultColumnConstraintContext { + var p = new(SerialDefaultColumnConstraintContext) + + InitEmptyColumnConstraintContext(&p.ColumnConstraintContext) + p.parser = parser + p.CopyAll(ctx.(*ColumnConstraintContext)) + + return p +} + +func (s *SerialDefaultColumnConstraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SerialDefaultColumnConstraintContext) SERIAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSERIAL, 0) +} + +func (s *SerialDefaultColumnConstraintContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(MySqlParserDEFAULT, 0) +} + +func (s *SerialDefaultColumnConstraintContext) VALUE() antlr.TerminalNode { + return s.GetToken(MySqlParserVALUE, 0) +} + +func (s *SerialDefaultColumnConstraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSerialDefaultColumnConstraint(s) + } +} + +func (s *SerialDefaultColumnConstraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSerialDefaultColumnConstraint(s) + } +} + +type GeneratedColumnConstraintContext struct { + ColumnConstraintContext +} + +func NewGeneratedColumnConstraintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *GeneratedColumnConstraintContext { + var p = new(GeneratedColumnConstraintContext) + + InitEmptyColumnConstraintContext(&p.ColumnConstraintContext) + p.parser = parser + p.CopyAll(ctx.(*ColumnConstraintContext)) + + return p +} + +func (s *GeneratedColumnConstraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *GeneratedColumnConstraintContext) AS() antlr.TerminalNode { + return s.GetToken(MySqlParserAS, 0) +} + +func (s *GeneratedColumnConstraintContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *GeneratedColumnConstraintContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *GeneratedColumnConstraintContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *GeneratedColumnConstraintContext) GENERATED() antlr.TerminalNode { + return s.GetToken(MySqlParserGENERATED, 0) +} + +func (s *GeneratedColumnConstraintContext) ALWAYS() antlr.TerminalNode { + return s.GetToken(MySqlParserALWAYS, 0) +} + +func (s *GeneratedColumnConstraintContext) VIRTUAL() antlr.TerminalNode { + return s.GetToken(MySqlParserVIRTUAL, 0) +} + +func (s *GeneratedColumnConstraintContext) STORED() antlr.TerminalNode { + return s.GetToken(MySqlParserSTORED, 0) +} + +func (s *GeneratedColumnConstraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterGeneratedColumnConstraint(s) + } +} + +func (s *GeneratedColumnConstraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitGeneratedColumnConstraint(s) + } +} + +type FormatColumnConstraintContext struct { + ColumnConstraintContext + colformat antlr.Token +} + +func NewFormatColumnConstraintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *FormatColumnConstraintContext { + var p = new(FormatColumnConstraintContext) + + InitEmptyColumnConstraintContext(&p.ColumnConstraintContext) + p.parser = parser + p.CopyAll(ctx.(*ColumnConstraintContext)) + + return p +} + +func (s *FormatColumnConstraintContext) GetColformat() antlr.Token { return s.colformat } + +func (s *FormatColumnConstraintContext) SetColformat(v antlr.Token) { s.colformat = v } + +func (s *FormatColumnConstraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FormatColumnConstraintContext) COLUMN_FORMAT() antlr.TerminalNode { + return s.GetToken(MySqlParserCOLUMN_FORMAT, 0) +} + +func (s *FormatColumnConstraintContext) FIXED() antlr.TerminalNode { + return s.GetToken(MySqlParserFIXED, 0) +} + +func (s *FormatColumnConstraintContext) DYNAMIC() antlr.TerminalNode { + return s.GetToken(MySqlParserDYNAMIC, 0) +} + +func (s *FormatColumnConstraintContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(MySqlParserDEFAULT, 0) +} + +func (s *FormatColumnConstraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterFormatColumnConstraint(s) + } +} + +func (s *FormatColumnConstraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitFormatColumnConstraint(s) + } +} + +type CollateColumnConstraintContext struct { + ColumnConstraintContext +} + +func NewCollateColumnConstraintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CollateColumnConstraintContext { + var p = new(CollateColumnConstraintContext) + + InitEmptyColumnConstraintContext(&p.ColumnConstraintContext) + p.parser = parser + p.CopyAll(ctx.(*ColumnConstraintContext)) + + return p +} + +func (s *CollateColumnConstraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CollateColumnConstraintContext) COLLATE() antlr.TerminalNode { + return s.GetToken(MySqlParserCOLLATE, 0) +} + +func (s *CollateColumnConstraintContext) CollationName() ICollationNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICollationNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICollationNameContext) +} + +func (s *CollateColumnConstraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCollateColumnConstraint(s) + } +} + +func (s *CollateColumnConstraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCollateColumnConstraint(s) + } +} + +type PrimaryKeyColumnConstraintContext struct { + ColumnConstraintContext +} + +func NewPrimaryKeyColumnConstraintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PrimaryKeyColumnConstraintContext { + var p = new(PrimaryKeyColumnConstraintContext) + + InitEmptyColumnConstraintContext(&p.ColumnConstraintContext) + p.parser = parser + p.CopyAll(ctx.(*ColumnConstraintContext)) + + return p +} + +func (s *PrimaryKeyColumnConstraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PrimaryKeyColumnConstraintContext) KEY() antlr.TerminalNode { + return s.GetToken(MySqlParserKEY, 0) +} + +func (s *PrimaryKeyColumnConstraintContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(MySqlParserPRIMARY, 0) +} + +func (s *PrimaryKeyColumnConstraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterPrimaryKeyColumnConstraint(s) + } +} + +func (s *PrimaryKeyColumnConstraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitPrimaryKeyColumnConstraint(s) + } +} + +type CheckColumnConstraintContext struct { + ColumnConstraintContext + name IUidContext +} + +func NewCheckColumnConstraintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CheckColumnConstraintContext { + var p = new(CheckColumnConstraintContext) + + InitEmptyColumnConstraintContext(&p.ColumnConstraintContext) + p.parser = parser + p.CopyAll(ctx.(*ColumnConstraintContext)) + + return p +} + +func (s *CheckColumnConstraintContext) GetName() IUidContext { return s.name } + +func (s *CheckColumnConstraintContext) SetName(v IUidContext) { s.name = v } + +func (s *CheckColumnConstraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CheckColumnConstraintContext) CHECK() antlr.TerminalNode { + return s.GetToken(MySqlParserCHECK, 0) +} + +func (s *CheckColumnConstraintContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *CheckColumnConstraintContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *CheckColumnConstraintContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *CheckColumnConstraintContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(MySqlParserCONSTRAINT, 0) +} + +func (s *CheckColumnConstraintContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *CheckColumnConstraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCheckColumnConstraint(s) + } +} + +func (s *CheckColumnConstraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCheckColumnConstraint(s) + } +} + +type NullColumnConstraintContext struct { + ColumnConstraintContext +} + +func NewNullColumnConstraintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NullColumnConstraintContext { + var p = new(NullColumnConstraintContext) + + InitEmptyColumnConstraintContext(&p.ColumnConstraintContext) + p.parser = parser + p.CopyAll(ctx.(*ColumnConstraintContext)) + + return p +} + +func (s *NullColumnConstraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *NullColumnConstraintContext) NullNotnull() INullNotnullContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INullNotnullContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INullNotnullContext) +} + +func (s *NullColumnConstraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterNullColumnConstraint(s) + } +} + +func (s *NullColumnConstraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitNullColumnConstraint(s) + } +} + +type DefaultColumnConstraintContext struct { + ColumnConstraintContext +} + +func NewDefaultColumnConstraintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DefaultColumnConstraintContext { + var p = new(DefaultColumnConstraintContext) + + InitEmptyColumnConstraintContext(&p.ColumnConstraintContext) + p.parser = parser + p.CopyAll(ctx.(*ColumnConstraintContext)) + + return p +} + +func (s *DefaultColumnConstraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DefaultColumnConstraintContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(MySqlParserDEFAULT, 0) +} + +func (s *DefaultColumnConstraintContext) DefaultValue() IDefaultValueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefaultValueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefaultValueContext) +} + +func (s *DefaultColumnConstraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterDefaultColumnConstraint(s) + } +} + +func (s *DefaultColumnConstraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitDefaultColumnConstraint(s) + } +} + +type ReferenceColumnConstraintContext struct { + ColumnConstraintContext +} + +func NewReferenceColumnConstraintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ReferenceColumnConstraintContext { + var p = new(ReferenceColumnConstraintContext) + + InitEmptyColumnConstraintContext(&p.ColumnConstraintContext) + p.parser = parser + p.CopyAll(ctx.(*ColumnConstraintContext)) + + return p +} + +func (s *ReferenceColumnConstraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ReferenceColumnConstraintContext) ReferenceDefinition() IReferenceDefinitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReferenceDefinitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReferenceDefinitionContext) +} + +func (s *ReferenceColumnConstraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterReferenceColumnConstraint(s) + } +} + +func (s *ReferenceColumnConstraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitReferenceColumnConstraint(s) + } +} + +type InvisibilityColumnConstraintContext struct { + ColumnConstraintContext +} + +func NewInvisibilityColumnConstraintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *InvisibilityColumnConstraintContext { + var p = new(InvisibilityColumnConstraintContext) + + InitEmptyColumnConstraintContext(&p.ColumnConstraintContext) + p.parser = parser + p.CopyAll(ctx.(*ColumnConstraintContext)) + + return p +} + +func (s *InvisibilityColumnConstraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *InvisibilityColumnConstraintContext) INVISIBLE() antlr.TerminalNode { + return s.GetToken(MySqlParserINVISIBLE, 0) +} + +func (s *InvisibilityColumnConstraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterInvisibilityColumnConstraint(s) + } +} + +func (s *InvisibilityColumnConstraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitInvisibilityColumnConstraint(s) + } +} + +func (p *MySqlParser) ColumnConstraint() (localctx IColumnConstraintContext) { + localctx = NewColumnConstraintContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 94, MySqlParserRULE_columnConstraint) + var _la int + + p.SetState(1681) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserNOT, MySqlParserNULL_LITERAL, MySqlParserNULL_SPEC_LITERAL: + localctx = NewNullColumnConstraintContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1628) + p.NullNotnull() + } + + case MySqlParserDEFAULT: + localctx = NewDefaultColumnConstraintContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1629) + p.Match(MySqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1630) + p.DefaultValue() + } + + case MySqlParserVISIBLE: + localctx = NewVisibilityColumnConstraintContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1631) + p.Match(MySqlParserVISIBLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserINVISIBLE: + localctx = NewInvisibilityColumnConstraintContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(1632) + p.Match(MySqlParserINVISIBLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserON, MySqlParserAUTO_INCREMENT: + localctx = NewAutoIncrementColumnConstraintContext(p, localctx) + p.EnterOuterAlt(localctx, 5) + p.SetState(1637) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserAUTO_INCREMENT: + { + p.SetState(1633) + p.Match(MySqlParserAUTO_INCREMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserON: + { + p.SetState(1634) + p.Match(MySqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1635) + p.Match(MySqlParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1636) + p.CurrentTimestamp() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case MySqlParserKEY, MySqlParserPRIMARY: + localctx = NewPrimaryKeyColumnConstraintContext(p, localctx) + p.EnterOuterAlt(localctx, 6) + p.SetState(1640) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserPRIMARY { + { + p.SetState(1639) + p.Match(MySqlParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1642) + p.Match(MySqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserUNIQUE: + localctx = NewUniqueKeyColumnConstraintContext(p, localctx) + p.EnterOuterAlt(localctx, 7) + { + p.SetState(1643) + p.Match(MySqlParserUNIQUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1645) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 154, p.GetParserRuleContext()) == 1 { + { + p.SetState(1644) + p.Match(MySqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case MySqlParserCOMMENT: + localctx = NewCommentColumnConstraintContext(p, localctx) + p.EnterOuterAlt(localctx, 8) + { + p.SetState(1647) + p.Match(MySqlParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1648) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserCOLUMN_FORMAT: + localctx = NewFormatColumnConstraintContext(p, localctx) + p.EnterOuterAlt(localctx, 9) + { + p.SetState(1649) + p.Match(MySqlParserCOLUMN_FORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1650) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*FormatColumnConstraintContext).colformat = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserDEFAULT || _la == MySqlParserDYNAMIC || _la == MySqlParserFIXED) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*FormatColumnConstraintContext).colformat = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case MySqlParserSTORAGE: + localctx = NewStorageColumnConstraintContext(p, localctx) + p.EnterOuterAlt(localctx, 10) + { + p.SetState(1651) + p.Match(MySqlParserSTORAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1652) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*StorageColumnConstraintContext).storageval = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserDEFAULT || _la == MySqlParserDISK || _la == MySqlParserMEMORY) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*StorageColumnConstraintContext).storageval = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case MySqlParserREFERENCES: + localctx = NewReferenceColumnConstraintContext(p, localctx) + p.EnterOuterAlt(localctx, 11) + { + p.SetState(1653) + p.ReferenceDefinition() + } + + case MySqlParserCOLLATE: + localctx = NewCollateColumnConstraintContext(p, localctx) + p.EnterOuterAlt(localctx, 12) + { + p.SetState(1654) + p.Match(MySqlParserCOLLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1655) + p.CollationName() + } + + case MySqlParserAS, MySqlParserGENERATED: + localctx = NewGeneratedColumnConstraintContext(p, localctx) + p.EnterOuterAlt(localctx, 13) + p.SetState(1658) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserGENERATED { + { + p.SetState(1656) + p.Match(MySqlParserGENERATED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1657) + p.Match(MySqlParserALWAYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1660) + p.Match(MySqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1661) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1662) + p.expression(0) + } + { + p.SetState(1663) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1665) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserSTORED || _la == MySqlParserVIRTUAL { + { + p.SetState(1664) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserSTORED || _la == MySqlParserVIRTUAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + + case MySqlParserSERIAL: + localctx = NewSerialDefaultColumnConstraintContext(p, localctx) + p.EnterOuterAlt(localctx, 14) + { + p.SetState(1667) + p.Match(MySqlParserSERIAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1668) + p.Match(MySqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1669) + p.Match(MySqlParserVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserCHECK, MySqlParserCONSTRAINT: + localctx = NewCheckColumnConstraintContext(p, localctx) + p.EnterOuterAlt(localctx, 15) + p.SetState(1674) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserCONSTRAINT { + { + p.SetState(1670) + p.Match(MySqlParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1672) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-34354363873) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-2199023255553) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-5764611921080745985) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-8796126576641) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-32651097298436097) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-18014398517872129) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-137438953601) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-44473063500156929) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-129) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-12289) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&-1) != 0) || ((int64((_la-1128)) & ^0x3f) == 0 && ((int64(1)<<(_la-1128))&8627683329) != 0) { + { + p.SetState(1671) + + var _x = p.Uid() + + localctx.(*CheckColumnConstraintContext).name = _x + } + + } + + } + { + p.SetState(1676) + p.Match(MySqlParserCHECK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1677) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1678) + p.expression(0) + } + { + p.SetState(1679) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITableConstraintContext is an interface to support dynamic dispatch. +type ITableConstraintContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsTableConstraintContext differentiates from other interfaces. + IsTableConstraintContext() +} + +type TableConstraintContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTableConstraintContext() *TableConstraintContext { + var p = new(TableConstraintContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_tableConstraint + return p +} + +func InitEmptyTableConstraintContext(p *TableConstraintContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_tableConstraint +} + +func (*TableConstraintContext) IsTableConstraintContext() {} + +func NewTableConstraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableConstraintContext { + var p = new(TableConstraintContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_tableConstraint + + return p +} + +func (s *TableConstraintContext) GetParser() antlr.Parser { return s.parser } + +func (s *TableConstraintContext) CopyAll(ctx *TableConstraintContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *TableConstraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableConstraintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type UniqueKeyTableConstraintContext struct { + TableConstraintContext + name IUidContext + indexFormat antlr.Token + index IUidContext +} + +func NewUniqueKeyTableConstraintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *UniqueKeyTableConstraintContext { + var p = new(UniqueKeyTableConstraintContext) + + InitEmptyTableConstraintContext(&p.TableConstraintContext) + p.parser = parser + p.CopyAll(ctx.(*TableConstraintContext)) + + return p +} + +func (s *UniqueKeyTableConstraintContext) GetIndexFormat() antlr.Token { return s.indexFormat } + +func (s *UniqueKeyTableConstraintContext) SetIndexFormat(v antlr.Token) { s.indexFormat = v } + +func (s *UniqueKeyTableConstraintContext) GetName() IUidContext { return s.name } + +func (s *UniqueKeyTableConstraintContext) GetIndex() IUidContext { return s.index } + +func (s *UniqueKeyTableConstraintContext) SetName(v IUidContext) { s.name = v } + +func (s *UniqueKeyTableConstraintContext) SetIndex(v IUidContext) { s.index = v } + +func (s *UniqueKeyTableConstraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UniqueKeyTableConstraintContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(MySqlParserUNIQUE, 0) +} + +func (s *UniqueKeyTableConstraintContext) IndexColumnNames() IIndexColumnNamesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexColumnNamesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndexColumnNamesContext) +} + +func (s *UniqueKeyTableConstraintContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(MySqlParserCONSTRAINT, 0) +} + +func (s *UniqueKeyTableConstraintContext) IndexType() IIndexTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndexTypeContext) +} + +func (s *UniqueKeyTableConstraintContext) AllIndexOption() []IIndexOptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIndexOptionContext); ok { + len++ + } + } + + tst := make([]IIndexOptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIndexOptionContext); ok { + tst[i] = t.(IIndexOptionContext) + i++ + } + } + + return tst +} + +func (s *UniqueKeyTableConstraintContext) IndexOption(i int) IIndexOptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexOptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIndexOptionContext) +} + +func (s *UniqueKeyTableConstraintContext) AllUid() []IUidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUidContext); ok { + len++ + } + } + + tst := make([]IUidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUidContext); ok { + tst[i] = t.(IUidContext) + i++ + } + } + + return tst +} + +func (s *UniqueKeyTableConstraintContext) Uid(i int) IUidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *UniqueKeyTableConstraintContext) INDEX() antlr.TerminalNode { + return s.GetToken(MySqlParserINDEX, 0) +} + +func (s *UniqueKeyTableConstraintContext) KEY() antlr.TerminalNode { + return s.GetToken(MySqlParserKEY, 0) +} + +func (s *UniqueKeyTableConstraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterUniqueKeyTableConstraint(s) + } +} + +func (s *UniqueKeyTableConstraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitUniqueKeyTableConstraint(s) + } +} + +type CheckTableConstraintContext struct { + TableConstraintContext + name IUidContext +} + +func NewCheckTableConstraintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CheckTableConstraintContext { + var p = new(CheckTableConstraintContext) + + InitEmptyTableConstraintContext(&p.TableConstraintContext) + p.parser = parser + p.CopyAll(ctx.(*TableConstraintContext)) + + return p +} + +func (s *CheckTableConstraintContext) GetName() IUidContext { return s.name } + +func (s *CheckTableConstraintContext) SetName(v IUidContext) { s.name = v } + +func (s *CheckTableConstraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CheckTableConstraintContext) CHECK() antlr.TerminalNode { + return s.GetToken(MySqlParserCHECK, 0) +} + +func (s *CheckTableConstraintContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *CheckTableConstraintContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *CheckTableConstraintContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *CheckTableConstraintContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(MySqlParserCONSTRAINT, 0) +} + +func (s *CheckTableConstraintContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *CheckTableConstraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCheckTableConstraint(s) + } +} + +func (s *CheckTableConstraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCheckTableConstraint(s) + } +} + +type PrimaryKeyTableConstraintContext struct { + TableConstraintContext + name IUidContext + index IUidContext +} + +func NewPrimaryKeyTableConstraintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PrimaryKeyTableConstraintContext { + var p = new(PrimaryKeyTableConstraintContext) + + InitEmptyTableConstraintContext(&p.TableConstraintContext) + p.parser = parser + p.CopyAll(ctx.(*TableConstraintContext)) + + return p +} + +func (s *PrimaryKeyTableConstraintContext) GetName() IUidContext { return s.name } + +func (s *PrimaryKeyTableConstraintContext) GetIndex() IUidContext { return s.index } + +func (s *PrimaryKeyTableConstraintContext) SetName(v IUidContext) { s.name = v } + +func (s *PrimaryKeyTableConstraintContext) SetIndex(v IUidContext) { s.index = v } + +func (s *PrimaryKeyTableConstraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PrimaryKeyTableConstraintContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(MySqlParserPRIMARY, 0) +} + +func (s *PrimaryKeyTableConstraintContext) KEY() antlr.TerminalNode { + return s.GetToken(MySqlParserKEY, 0) +} + +func (s *PrimaryKeyTableConstraintContext) IndexColumnNames() IIndexColumnNamesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexColumnNamesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndexColumnNamesContext) +} + +func (s *PrimaryKeyTableConstraintContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(MySqlParserCONSTRAINT, 0) +} + +func (s *PrimaryKeyTableConstraintContext) IndexType() IIndexTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndexTypeContext) +} + +func (s *PrimaryKeyTableConstraintContext) AllIndexOption() []IIndexOptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIndexOptionContext); ok { + len++ + } + } + + tst := make([]IIndexOptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIndexOptionContext); ok { + tst[i] = t.(IIndexOptionContext) + i++ + } + } + + return tst +} + +func (s *PrimaryKeyTableConstraintContext) IndexOption(i int) IIndexOptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexOptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIndexOptionContext) +} + +func (s *PrimaryKeyTableConstraintContext) AllUid() []IUidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUidContext); ok { + len++ + } + } + + tst := make([]IUidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUidContext); ok { + tst[i] = t.(IUidContext) + i++ + } + } + + return tst +} + +func (s *PrimaryKeyTableConstraintContext) Uid(i int) IUidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *PrimaryKeyTableConstraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterPrimaryKeyTableConstraint(s) + } +} + +func (s *PrimaryKeyTableConstraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitPrimaryKeyTableConstraint(s) + } +} + +type ForeignKeyTableConstraintContext struct { + TableConstraintContext + name IUidContext + index IUidContext +} + +func NewForeignKeyTableConstraintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ForeignKeyTableConstraintContext { + var p = new(ForeignKeyTableConstraintContext) + + InitEmptyTableConstraintContext(&p.TableConstraintContext) + p.parser = parser + p.CopyAll(ctx.(*TableConstraintContext)) + + return p +} + +func (s *ForeignKeyTableConstraintContext) GetName() IUidContext { return s.name } + +func (s *ForeignKeyTableConstraintContext) GetIndex() IUidContext { return s.index } + +func (s *ForeignKeyTableConstraintContext) SetName(v IUidContext) { s.name = v } + +func (s *ForeignKeyTableConstraintContext) SetIndex(v IUidContext) { s.index = v } + +func (s *ForeignKeyTableConstraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ForeignKeyTableConstraintContext) FOREIGN() antlr.TerminalNode { + return s.GetToken(MySqlParserFOREIGN, 0) +} + +func (s *ForeignKeyTableConstraintContext) KEY() antlr.TerminalNode { + return s.GetToken(MySqlParserKEY, 0) +} + +func (s *ForeignKeyTableConstraintContext) IndexColumnNames() IIndexColumnNamesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexColumnNamesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndexColumnNamesContext) +} + +func (s *ForeignKeyTableConstraintContext) ReferenceDefinition() IReferenceDefinitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReferenceDefinitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReferenceDefinitionContext) +} + +func (s *ForeignKeyTableConstraintContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(MySqlParserCONSTRAINT, 0) +} + +func (s *ForeignKeyTableConstraintContext) AllUid() []IUidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUidContext); ok { + len++ + } + } + + tst := make([]IUidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUidContext); ok { + tst[i] = t.(IUidContext) + i++ + } + } + + return tst +} + +func (s *ForeignKeyTableConstraintContext) Uid(i int) IUidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *ForeignKeyTableConstraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterForeignKeyTableConstraint(s) + } +} + +func (s *ForeignKeyTableConstraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitForeignKeyTableConstraint(s) + } +} + +func (p *MySqlParser) TableConstraint() (localctx ITableConstraintContext) { + localctx = NewTableConstraintContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 96, MySqlParserRULE_tableConstraint) + var _la int + + p.SetState(1752) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 176, p.GetParserRuleContext()) { + case 1: + localctx = NewPrimaryKeyTableConstraintContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + p.SetState(1687) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserCONSTRAINT { + { + p.SetState(1683) + p.Match(MySqlParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1685) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 160, p.GetParserRuleContext()) == 1 { + { + p.SetState(1684) + + var _x = p.Uid() + + localctx.(*PrimaryKeyTableConstraintContext).name = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } + { + p.SetState(1689) + p.Match(MySqlParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1690) + p.Match(MySqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1692) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-34354363873) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-2199023255553) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-5764611921080745985) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-8796126576641) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-32651097298436097) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-18014398517872129) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-137438953601) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-44473063500156929) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-129) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-12289) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&-1) != 0) || ((int64((_la-1128)) & ^0x3f) == 0 && ((int64(1)<<(_la-1128))&8627683329) != 0) { + { + p.SetState(1691) + + var _x = p.Uid() + + localctx.(*PrimaryKeyTableConstraintContext).index = _x + } + + } + p.SetState(1695) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserUSING { + { + p.SetState(1694) + p.IndexType() + } + + } + { + p.SetState(1697) + p.IndexColumnNames() + } + p.SetState(1701) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserUSING || _la == MySqlParserWITH || _la == MySqlParserCOMMENT || _la == MySqlParserINVISIBLE || _la == MySqlParserKEY_BLOCK_SIZE || _la == MySqlParserVISIBLE || _la == MySqlParserENGINE_ATTRIBUTE || _la == MySqlParserSECONDARY_ENGINE_ATTRIBUTE { + { + p.SetState(1698) + p.IndexOption() + } + + p.SetState(1703) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 2: + localctx = NewUniqueKeyTableConstraintContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + p.SetState(1708) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserCONSTRAINT { + { + p.SetState(1704) + p.Match(MySqlParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1706) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-34354363873) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-2199023255553) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-5764611921080745985) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-8796126576641) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-32651097298436097) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-18014398517872129) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-137438953601) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-44473063500156929) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-129) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-12289) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&-1) != 0) || ((int64((_la-1128)) & ^0x3f) == 0 && ((int64(1)<<(_la-1128))&8627683329) != 0) { + { + p.SetState(1705) + + var _x = p.Uid() + + localctx.(*UniqueKeyTableConstraintContext).name = _x + } + + } + + } + { + p.SetState(1710) + p.Match(MySqlParserUNIQUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1712) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserINDEX || _la == MySqlParserKEY { + { + p.SetState(1711) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*UniqueKeyTableConstraintContext).indexFormat = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserINDEX || _la == MySqlParserKEY) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*UniqueKeyTableConstraintContext).indexFormat = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(1715) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-34354363873) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-2199023255553) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-5764611921080745985) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-8796126576641) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-32651097298436097) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-18014398517872129) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-137438953601) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-44473063500156929) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-129) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-12289) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&-1) != 0) || ((int64((_la-1128)) & ^0x3f) == 0 && ((int64(1)<<(_la-1128))&8627683329) != 0) { + { + p.SetState(1714) + + var _x = p.Uid() + + localctx.(*UniqueKeyTableConstraintContext).index = _x + } + + } + p.SetState(1718) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserUSING { + { + p.SetState(1717) + p.IndexType() + } + + } + { + p.SetState(1720) + p.IndexColumnNames() + } + p.SetState(1724) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserUSING || _la == MySqlParserWITH || _la == MySqlParserCOMMENT || _la == MySqlParserINVISIBLE || _la == MySqlParserKEY_BLOCK_SIZE || _la == MySqlParserVISIBLE || _la == MySqlParserENGINE_ATTRIBUTE || _la == MySqlParserSECONDARY_ENGINE_ATTRIBUTE { + { + p.SetState(1721) + p.IndexOption() + } + + p.SetState(1726) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 3: + localctx = NewForeignKeyTableConstraintContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + p.SetState(1731) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserCONSTRAINT { + { + p.SetState(1727) + p.Match(MySqlParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1729) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-34354363873) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-2199023255553) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-5764611921080745985) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-8796126576641) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-32651097298436097) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-18014398517872129) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-137438953601) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-44473063500156929) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-129) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-12289) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&-1) != 0) || ((int64((_la-1128)) & ^0x3f) == 0 && ((int64(1)<<(_la-1128))&8627683329) != 0) { + { + p.SetState(1728) + + var _x = p.Uid() + + localctx.(*ForeignKeyTableConstraintContext).name = _x + } + + } + + } + { + p.SetState(1733) + p.Match(MySqlParserFOREIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1734) + p.Match(MySqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1736) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-34354363873) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-2199023255553) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-5764611921080745985) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-8796126576641) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-32651097298436097) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-18014398517872129) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-137438953601) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-44473063500156929) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-129) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-12289) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&-1) != 0) || ((int64((_la-1128)) & ^0x3f) == 0 && ((int64(1)<<(_la-1128))&8627683329) != 0) { + { + p.SetState(1735) + + var _x = p.Uid() + + localctx.(*ForeignKeyTableConstraintContext).index = _x + } + + } + { + p.SetState(1738) + p.IndexColumnNames() + } + { + p.SetState(1739) + p.ReferenceDefinition() + } + + case 4: + localctx = NewCheckTableConstraintContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + p.SetState(1745) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserCONSTRAINT { + { + p.SetState(1741) + p.Match(MySqlParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1743) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-34354363873) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-2199023255553) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-5764611921080745985) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-8796126576641) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-32651097298436097) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-18014398517872129) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-137438953601) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-44473063500156929) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-129) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-12289) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&-1) != 0) || ((int64((_la-1128)) & ^0x3f) == 0 && ((int64(1)<<(_la-1128))&8627683329) != 0) { + { + p.SetState(1742) + + var _x = p.Uid() + + localctx.(*CheckTableConstraintContext).name = _x + } + + } + + } + { + p.SetState(1747) + p.Match(MySqlParserCHECK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1748) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1749) + p.expression(0) + } + { + p.SetState(1750) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReferenceDefinitionContext is an interface to support dynamic dispatch. +type IReferenceDefinitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetMatchType returns the matchType token. + GetMatchType() antlr.Token + + // SetMatchType sets the matchType token. + SetMatchType(antlr.Token) + + // Getter signatures + REFERENCES() antlr.TerminalNode + TableName() ITableNameContext + IndexColumnNames() IIndexColumnNamesContext + MATCH() antlr.TerminalNode + ReferenceAction() IReferenceActionContext + FULL() antlr.TerminalNode + PARTIAL() antlr.TerminalNode + SIMPLE() antlr.TerminalNode + + // IsReferenceDefinitionContext differentiates from other interfaces. + IsReferenceDefinitionContext() +} + +type ReferenceDefinitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + matchType antlr.Token +} + +func NewEmptyReferenceDefinitionContext() *ReferenceDefinitionContext { + var p = new(ReferenceDefinitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_referenceDefinition + return p +} + +func InitEmptyReferenceDefinitionContext(p *ReferenceDefinitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_referenceDefinition +} + +func (*ReferenceDefinitionContext) IsReferenceDefinitionContext() {} + +func NewReferenceDefinitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReferenceDefinitionContext { + var p = new(ReferenceDefinitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_referenceDefinition + + return p +} + +func (s *ReferenceDefinitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *ReferenceDefinitionContext) GetMatchType() antlr.Token { return s.matchType } + +func (s *ReferenceDefinitionContext) SetMatchType(v antlr.Token) { s.matchType = v } + +func (s *ReferenceDefinitionContext) REFERENCES() antlr.TerminalNode { + return s.GetToken(MySqlParserREFERENCES, 0) +} + +func (s *ReferenceDefinitionContext) TableName() ITableNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableNameContext) +} + +func (s *ReferenceDefinitionContext) IndexColumnNames() IIndexColumnNamesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexColumnNamesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndexColumnNamesContext) +} + +func (s *ReferenceDefinitionContext) MATCH() antlr.TerminalNode { + return s.GetToken(MySqlParserMATCH, 0) +} + +func (s *ReferenceDefinitionContext) ReferenceAction() IReferenceActionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReferenceActionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReferenceActionContext) +} + +func (s *ReferenceDefinitionContext) FULL() antlr.TerminalNode { + return s.GetToken(MySqlParserFULL, 0) +} + +func (s *ReferenceDefinitionContext) PARTIAL() antlr.TerminalNode { + return s.GetToken(MySqlParserPARTIAL, 0) +} + +func (s *ReferenceDefinitionContext) SIMPLE() antlr.TerminalNode { + return s.GetToken(MySqlParserSIMPLE, 0) +} + +func (s *ReferenceDefinitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ReferenceDefinitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ReferenceDefinitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterReferenceDefinition(s) + } +} + +func (s *ReferenceDefinitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitReferenceDefinition(s) + } +} + +func (p *MySqlParser) ReferenceDefinition() (localctx IReferenceDefinitionContext) { + localctx = NewReferenceDefinitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 98, MySqlParserRULE_referenceDefinition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1754) + p.Match(MySqlParserREFERENCES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1755) + p.TableName() + } + p.SetState(1757) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 177, p.GetParserRuleContext()) == 1 { + { + p.SetState(1756) + p.IndexColumnNames() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(1761) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserMATCH { + { + p.SetState(1759) + p.Match(MySqlParserMATCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1760) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*ReferenceDefinitionContext).matchType = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserFULL || _la == MySqlParserPARTIAL || _la == MySqlParserSIMPLE) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*ReferenceDefinitionContext).matchType = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(1764) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 179, p.GetParserRuleContext()) == 1 { + { + p.SetState(1763) + p.ReferenceAction() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReferenceActionContext is an interface to support dynamic dispatch. +type IReferenceActionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetOnDelete returns the onDelete rule contexts. + GetOnDelete() IReferenceControlTypeContext + + // GetOnUpdate returns the onUpdate rule contexts. + GetOnUpdate() IReferenceControlTypeContext + + // SetOnDelete sets the onDelete rule contexts. + SetOnDelete(IReferenceControlTypeContext) + + // SetOnUpdate sets the onUpdate rule contexts. + SetOnUpdate(IReferenceControlTypeContext) + + // Getter signatures + AllON() []antlr.TerminalNode + ON(i int) antlr.TerminalNode + DELETE() antlr.TerminalNode + AllReferenceControlType() []IReferenceControlTypeContext + ReferenceControlType(i int) IReferenceControlTypeContext + UPDATE() antlr.TerminalNode + + // IsReferenceActionContext differentiates from other interfaces. + IsReferenceActionContext() +} + +type ReferenceActionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + onDelete IReferenceControlTypeContext + onUpdate IReferenceControlTypeContext +} + +func NewEmptyReferenceActionContext() *ReferenceActionContext { + var p = new(ReferenceActionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_referenceAction + return p +} + +func InitEmptyReferenceActionContext(p *ReferenceActionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_referenceAction +} + +func (*ReferenceActionContext) IsReferenceActionContext() {} + +func NewReferenceActionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReferenceActionContext { + var p = new(ReferenceActionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_referenceAction + + return p +} + +func (s *ReferenceActionContext) GetParser() antlr.Parser { return s.parser } + +func (s *ReferenceActionContext) GetOnDelete() IReferenceControlTypeContext { return s.onDelete } + +func (s *ReferenceActionContext) GetOnUpdate() IReferenceControlTypeContext { return s.onUpdate } + +func (s *ReferenceActionContext) SetOnDelete(v IReferenceControlTypeContext) { s.onDelete = v } + +func (s *ReferenceActionContext) SetOnUpdate(v IReferenceControlTypeContext) { s.onUpdate = v } + +func (s *ReferenceActionContext) AllON() []antlr.TerminalNode { + return s.GetTokens(MySqlParserON) +} + +func (s *ReferenceActionContext) ON(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserON, i) +} + +func (s *ReferenceActionContext) DELETE() antlr.TerminalNode { + return s.GetToken(MySqlParserDELETE, 0) +} + +func (s *ReferenceActionContext) AllReferenceControlType() []IReferenceControlTypeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IReferenceControlTypeContext); ok { + len++ + } + } + + tst := make([]IReferenceControlTypeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IReferenceControlTypeContext); ok { + tst[i] = t.(IReferenceControlTypeContext) + i++ + } + } + + return tst +} + +func (s *ReferenceActionContext) ReferenceControlType(i int) IReferenceControlTypeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReferenceControlTypeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IReferenceControlTypeContext) +} + +func (s *ReferenceActionContext) UPDATE() antlr.TerminalNode { + return s.GetToken(MySqlParserUPDATE, 0) +} + +func (s *ReferenceActionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ReferenceActionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ReferenceActionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterReferenceAction(s) + } +} + +func (s *ReferenceActionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitReferenceAction(s) + } +} + +func (p *MySqlParser) ReferenceAction() (localctx IReferenceActionContext) { + localctx = NewReferenceActionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 100, MySqlParserRULE_referenceAction) + p.SetState(1782) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 182, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1766) + p.Match(MySqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1767) + p.Match(MySqlParserDELETE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1768) + + var _x = p.ReferenceControlType() + + localctx.(*ReferenceActionContext).onDelete = _x + } + p.SetState(1772) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 180, p.GetParserRuleContext()) == 1 { + { + p.SetState(1769) + p.Match(MySqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1770) + p.Match(MySqlParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1771) + + var _x = p.ReferenceControlType() + + localctx.(*ReferenceActionContext).onUpdate = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1774) + p.Match(MySqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1775) + p.Match(MySqlParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1776) + + var _x = p.ReferenceControlType() + + localctx.(*ReferenceActionContext).onUpdate = _x + } + p.SetState(1780) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 181, p.GetParserRuleContext()) == 1 { + { + p.SetState(1777) + p.Match(MySqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1778) + p.Match(MySqlParserDELETE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1779) + + var _x = p.ReferenceControlType() + + localctx.(*ReferenceActionContext).onDelete = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReferenceControlTypeContext is an interface to support dynamic dispatch. +type IReferenceControlTypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RESTRICT() antlr.TerminalNode + CASCADE() antlr.TerminalNode + SET() antlr.TerminalNode + NULL_LITERAL() antlr.TerminalNode + NO() antlr.TerminalNode + ACTION() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + + // IsReferenceControlTypeContext differentiates from other interfaces. + IsReferenceControlTypeContext() +} + +type ReferenceControlTypeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReferenceControlTypeContext() *ReferenceControlTypeContext { + var p = new(ReferenceControlTypeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_referenceControlType + return p +} + +func InitEmptyReferenceControlTypeContext(p *ReferenceControlTypeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_referenceControlType +} + +func (*ReferenceControlTypeContext) IsReferenceControlTypeContext() {} + +func NewReferenceControlTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReferenceControlTypeContext { + var p = new(ReferenceControlTypeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_referenceControlType + + return p +} + +func (s *ReferenceControlTypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *ReferenceControlTypeContext) RESTRICT() antlr.TerminalNode { + return s.GetToken(MySqlParserRESTRICT, 0) +} + +func (s *ReferenceControlTypeContext) CASCADE() antlr.TerminalNode { + return s.GetToken(MySqlParserCASCADE, 0) +} + +func (s *ReferenceControlTypeContext) SET() antlr.TerminalNode { + return s.GetToken(MySqlParserSET, 0) +} + +func (s *ReferenceControlTypeContext) NULL_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserNULL_LITERAL, 0) +} + +func (s *ReferenceControlTypeContext) NO() antlr.TerminalNode { + return s.GetToken(MySqlParserNO, 0) +} + +func (s *ReferenceControlTypeContext) ACTION() antlr.TerminalNode { + return s.GetToken(MySqlParserACTION, 0) +} + +func (s *ReferenceControlTypeContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(MySqlParserDEFAULT, 0) +} + +func (s *ReferenceControlTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ReferenceControlTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ReferenceControlTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterReferenceControlType(s) + } +} + +func (s *ReferenceControlTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitReferenceControlType(s) + } +} + +func (p *MySqlParser) ReferenceControlType() (localctx IReferenceControlTypeContext) { + localctx = NewReferenceControlTypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 102, MySqlParserRULE_referenceControlType) + p.SetState(1792) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 183, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1784) + p.Match(MySqlParserRESTRICT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1785) + p.Match(MySqlParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1786) + p.Match(MySqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1787) + p.Match(MySqlParserNULL_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(1788) + p.Match(MySqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1789) + p.Match(MySqlParserACTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(1790) + p.Match(MySqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1791) + p.Match(MySqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndexColumnDefinitionContext is an interface to support dynamic dispatch. +type IIndexColumnDefinitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsIndexColumnDefinitionContext differentiates from other interfaces. + IsIndexColumnDefinitionContext() +} + +type IndexColumnDefinitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndexColumnDefinitionContext() *IndexColumnDefinitionContext { + var p = new(IndexColumnDefinitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_indexColumnDefinition + return p +} + +func InitEmptyIndexColumnDefinitionContext(p *IndexColumnDefinitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_indexColumnDefinition +} + +func (*IndexColumnDefinitionContext) IsIndexColumnDefinitionContext() {} + +func NewIndexColumnDefinitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndexColumnDefinitionContext { + var p = new(IndexColumnDefinitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_indexColumnDefinition + + return p +} + +func (s *IndexColumnDefinitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *IndexColumnDefinitionContext) CopyAll(ctx *IndexColumnDefinitionContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *IndexColumnDefinitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IndexColumnDefinitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type SpecialIndexDeclarationContext struct { + IndexColumnDefinitionContext + indexFormat antlr.Token +} + +func NewSpecialIndexDeclarationContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SpecialIndexDeclarationContext { + var p = new(SpecialIndexDeclarationContext) + + InitEmptyIndexColumnDefinitionContext(&p.IndexColumnDefinitionContext) + p.parser = parser + p.CopyAll(ctx.(*IndexColumnDefinitionContext)) + + return p +} + +func (s *SpecialIndexDeclarationContext) GetIndexFormat() antlr.Token { return s.indexFormat } + +func (s *SpecialIndexDeclarationContext) SetIndexFormat(v antlr.Token) { s.indexFormat = v } + +func (s *SpecialIndexDeclarationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SpecialIndexDeclarationContext) IndexColumnNames() IIndexColumnNamesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexColumnNamesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndexColumnNamesContext) +} + +func (s *SpecialIndexDeclarationContext) FULLTEXT() antlr.TerminalNode { + return s.GetToken(MySqlParserFULLTEXT, 0) +} + +func (s *SpecialIndexDeclarationContext) SPATIAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSPATIAL, 0) +} + +func (s *SpecialIndexDeclarationContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *SpecialIndexDeclarationContext) AllIndexOption() []IIndexOptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIndexOptionContext); ok { + len++ + } + } + + tst := make([]IIndexOptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIndexOptionContext); ok { + tst[i] = t.(IIndexOptionContext) + i++ + } + } + + return tst +} + +func (s *SpecialIndexDeclarationContext) IndexOption(i int) IIndexOptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexOptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIndexOptionContext) +} + +func (s *SpecialIndexDeclarationContext) INDEX() antlr.TerminalNode { + return s.GetToken(MySqlParserINDEX, 0) +} + +func (s *SpecialIndexDeclarationContext) KEY() antlr.TerminalNode { + return s.GetToken(MySqlParserKEY, 0) +} + +func (s *SpecialIndexDeclarationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSpecialIndexDeclaration(s) + } +} + +func (s *SpecialIndexDeclarationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSpecialIndexDeclaration(s) + } +} + +type SimpleIndexDeclarationContext struct { + IndexColumnDefinitionContext + indexFormat antlr.Token +} + +func NewSimpleIndexDeclarationContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SimpleIndexDeclarationContext { + var p = new(SimpleIndexDeclarationContext) + + InitEmptyIndexColumnDefinitionContext(&p.IndexColumnDefinitionContext) + p.parser = parser + p.CopyAll(ctx.(*IndexColumnDefinitionContext)) + + return p +} + +func (s *SimpleIndexDeclarationContext) GetIndexFormat() antlr.Token { return s.indexFormat } + +func (s *SimpleIndexDeclarationContext) SetIndexFormat(v antlr.Token) { s.indexFormat = v } + +func (s *SimpleIndexDeclarationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SimpleIndexDeclarationContext) IndexColumnNames() IIndexColumnNamesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexColumnNamesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndexColumnNamesContext) +} + +func (s *SimpleIndexDeclarationContext) INDEX() antlr.TerminalNode { + return s.GetToken(MySqlParserINDEX, 0) +} + +func (s *SimpleIndexDeclarationContext) KEY() antlr.TerminalNode { + return s.GetToken(MySqlParserKEY, 0) +} + +func (s *SimpleIndexDeclarationContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *SimpleIndexDeclarationContext) IndexType() IIndexTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndexTypeContext) +} + +func (s *SimpleIndexDeclarationContext) AllIndexOption() []IIndexOptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIndexOptionContext); ok { + len++ + } + } + + tst := make([]IIndexOptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIndexOptionContext); ok { + tst[i] = t.(IIndexOptionContext) + i++ + } + } + + return tst +} + +func (s *SimpleIndexDeclarationContext) IndexOption(i int) IIndexOptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexOptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIndexOptionContext) +} + +func (s *SimpleIndexDeclarationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSimpleIndexDeclaration(s) + } +} + +func (s *SimpleIndexDeclarationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSimpleIndexDeclaration(s) + } +} + +func (p *MySqlParser) IndexColumnDefinition() (localctx IIndexColumnDefinitionContext) { + localctx = NewIndexColumnDefinitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 104, MySqlParserRULE_indexColumnDefinition) + var _la int + + p.SetState(1822) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserINDEX, MySqlParserKEY: + localctx = NewSimpleIndexDeclarationContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1794) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*SimpleIndexDeclarationContext).indexFormat = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserINDEX || _la == MySqlParserKEY) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*SimpleIndexDeclarationContext).indexFormat = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(1796) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-34354363873) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-2199023255553) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-5764611921080745985) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-8796126576641) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-32651097298436097) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-18014398517872129) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-137438953601) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-44473063500156929) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-129) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-12289) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&-1) != 0) || ((int64((_la-1128)) & ^0x3f) == 0 && ((int64(1)<<(_la-1128))&8627683329) != 0) { + { + p.SetState(1795) + p.Uid() + } + + } + p.SetState(1799) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserUSING { + { + p.SetState(1798) + p.IndexType() + } + + } + { + p.SetState(1801) + p.IndexColumnNames() + } + p.SetState(1805) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserUSING || _la == MySqlParserWITH || _la == MySqlParserCOMMENT || _la == MySqlParserINVISIBLE || _la == MySqlParserKEY_BLOCK_SIZE || _la == MySqlParserVISIBLE || _la == MySqlParserENGINE_ATTRIBUTE || _la == MySqlParserSECONDARY_ENGINE_ATTRIBUTE { + { + p.SetState(1802) + p.IndexOption() + } + + p.SetState(1807) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case MySqlParserFULLTEXT, MySqlParserSPATIAL: + localctx = NewSpecialIndexDeclarationContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1808) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserFULLTEXT || _la == MySqlParserSPATIAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(1810) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserINDEX || _la == MySqlParserKEY { + { + p.SetState(1809) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*SpecialIndexDeclarationContext).indexFormat = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserINDEX || _la == MySqlParserKEY) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*SpecialIndexDeclarationContext).indexFormat = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(1813) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-34354363873) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-2199023255553) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-5764611921080745985) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-8796126576641) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-32651097298436097) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-18014398517872129) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-137438953601) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-44473063500156929) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-129) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-12289) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&-1) != 0) || ((int64((_la-1128)) & ^0x3f) == 0 && ((int64(1)<<(_la-1128))&8627683329) != 0) { + { + p.SetState(1812) + p.Uid() + } + + } + { + p.SetState(1815) + p.IndexColumnNames() + } + p.SetState(1819) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserUSING || _la == MySqlParserWITH || _la == MySqlParserCOMMENT || _la == MySqlParserINVISIBLE || _la == MySqlParserKEY_BLOCK_SIZE || _la == MySqlParserVISIBLE || _la == MySqlParserENGINE_ATTRIBUTE || _la == MySqlParserSECONDARY_ENGINE_ATTRIBUTE { + { + p.SetState(1816) + p.IndexOption() + } + + p.SetState(1821) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITableOptionContext is an interface to support dynamic dispatch. +type ITableOptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsTableOptionContext differentiates from other interfaces. + IsTableOptionContext() +} + +type TableOptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTableOptionContext() *TableOptionContext { + var p = new(TableOptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_tableOption + return p +} + +func InitEmptyTableOptionContext(p *TableOptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_tableOption +} + +func (*TableOptionContext) IsTableOptionContext() {} + +func NewTableOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableOptionContext { + var p = new(TableOptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_tableOption + + return p +} + +func (s *TableOptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *TableOptionContext) CopyAll(ctx *TableOptionContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *TableOptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type TableOptionEngineContext struct { + TableOptionContext +} + +func NewTableOptionEngineContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionEngineContext { + var p = new(TableOptionEngineContext) + + InitEmptyTableOptionContext(&p.TableOptionContext) + p.parser = parser + p.CopyAll(ctx.(*TableOptionContext)) + + return p +} + +func (s *TableOptionEngineContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableOptionEngineContext) ENGINE() antlr.TerminalNode { + return s.GetToken(MySqlParserENGINE, 0) +} + +func (s *TableOptionEngineContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *TableOptionEngineContext) EngineName() IEngineNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEngineNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEngineNameContext) +} + +func (s *TableOptionEngineContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTableOptionEngine(s) + } +} + +func (s *TableOptionEngineContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTableOptionEngine(s) + } +} + +type TableOptionMaxRowsContext struct { + TableOptionContext +} + +func NewTableOptionMaxRowsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionMaxRowsContext { + var p = new(TableOptionMaxRowsContext) + + InitEmptyTableOptionContext(&p.TableOptionContext) + p.parser = parser + p.CopyAll(ctx.(*TableOptionContext)) + + return p +} + +func (s *TableOptionMaxRowsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableOptionMaxRowsContext) MAX_ROWS() antlr.TerminalNode { + return s.GetToken(MySqlParserMAX_ROWS, 0) +} + +func (s *TableOptionMaxRowsContext) DecimalLiteral() IDecimalLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *TableOptionMaxRowsContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *TableOptionMaxRowsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTableOptionMaxRows(s) + } +} + +func (s *TableOptionMaxRowsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTableOptionMaxRows(s) + } +} + +type TableOptionCollateContext struct { + TableOptionContext +} + +func NewTableOptionCollateContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionCollateContext { + var p = new(TableOptionCollateContext) + + InitEmptyTableOptionContext(&p.TableOptionContext) + p.parser = parser + p.CopyAll(ctx.(*TableOptionContext)) + + return p +} + +func (s *TableOptionCollateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableOptionCollateContext) COLLATE() antlr.TerminalNode { + return s.GetToken(MySqlParserCOLLATE, 0) +} + +func (s *TableOptionCollateContext) CollationName() ICollationNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICollationNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICollationNameContext) +} + +func (s *TableOptionCollateContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(MySqlParserDEFAULT, 0) +} + +func (s *TableOptionCollateContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *TableOptionCollateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTableOptionCollate(s) + } +} + +func (s *TableOptionCollateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTableOptionCollate(s) + } +} + +type TableOptionPersistentContext struct { + TableOptionContext + extBoolValue antlr.Token +} + +func NewTableOptionPersistentContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionPersistentContext { + var p = new(TableOptionPersistentContext) + + InitEmptyTableOptionContext(&p.TableOptionContext) + p.parser = parser + p.CopyAll(ctx.(*TableOptionContext)) + + return p +} + +func (s *TableOptionPersistentContext) GetExtBoolValue() antlr.Token { return s.extBoolValue } + +func (s *TableOptionPersistentContext) SetExtBoolValue(v antlr.Token) { s.extBoolValue = v } + +func (s *TableOptionPersistentContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableOptionPersistentContext) STATS_PERSISTENT() antlr.TerminalNode { + return s.GetToken(MySqlParserSTATS_PERSISTENT, 0) +} + +func (s *TableOptionPersistentContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(MySqlParserDEFAULT, 0) +} + +func (s *TableOptionPersistentContext) ZERO_DECIMAL() antlr.TerminalNode { + return s.GetToken(MySqlParserZERO_DECIMAL, 0) +} + +func (s *TableOptionPersistentContext) ONE_DECIMAL() antlr.TerminalNode { + return s.GetToken(MySqlParserONE_DECIMAL, 0) +} + +func (s *TableOptionPersistentContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *TableOptionPersistentContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTableOptionPersistent(s) + } +} + +func (s *TableOptionPersistentContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTableOptionPersistent(s) + } +} + +type TableOptionTablespaceContext struct { + TableOptionContext +} + +func NewTableOptionTablespaceContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionTablespaceContext { + var p = new(TableOptionTablespaceContext) + + InitEmptyTableOptionContext(&p.TableOptionContext) + p.parser = parser + p.CopyAll(ctx.(*TableOptionContext)) + + return p +} + +func (s *TableOptionTablespaceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableOptionTablespaceContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLESPACE, 0) +} + +func (s *TableOptionTablespaceContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *TableOptionTablespaceContext) TablespaceStorage() ITablespaceStorageContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceStorageContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceStorageContext) +} + +func (s *TableOptionTablespaceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTableOptionTablespace(s) + } +} + +func (s *TableOptionTablespaceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTableOptionTablespace(s) + } +} + +type TableOptionAutoextendSizeContext struct { + TableOptionContext +} + +func NewTableOptionAutoextendSizeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionAutoextendSizeContext { + var p = new(TableOptionAutoextendSizeContext) + + InitEmptyTableOptionContext(&p.TableOptionContext) + p.parser = parser + p.CopyAll(ctx.(*TableOptionContext)) + + return p +} + +func (s *TableOptionAutoextendSizeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableOptionAutoextendSizeContext) AUTOEXTEND_SIZE() antlr.TerminalNode { + return s.GetToken(MySqlParserAUTOEXTEND_SIZE, 0) +} + +func (s *TableOptionAutoextendSizeContext) DecimalLiteral() IDecimalLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *TableOptionAutoextendSizeContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *TableOptionAutoextendSizeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTableOptionAutoextendSize(s) + } +} + +func (s *TableOptionAutoextendSizeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTableOptionAutoextendSize(s) + } +} + +type TableOptionPageCompressedContext struct { + TableOptionContext +} + +func NewTableOptionPageCompressedContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionPageCompressedContext { + var p = new(TableOptionPageCompressedContext) + + InitEmptyTableOptionContext(&p.TableOptionContext) + p.parser = parser + p.CopyAll(ctx.(*TableOptionContext)) + + return p +} + +func (s *TableOptionPageCompressedContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableOptionPageCompressedContext) PAGE_COMPRESSED() antlr.TerminalNode { + return s.GetToken(MySqlParserPAGE_COMPRESSED, 0) +} + +func (s *TableOptionPageCompressedContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *TableOptionPageCompressedContext) ZERO_DECIMAL() antlr.TerminalNode { + return s.GetToken(MySqlParserZERO_DECIMAL, 0) +} + +func (s *TableOptionPageCompressedContext) ONE_DECIMAL() antlr.TerminalNode { + return s.GetToken(MySqlParserONE_DECIMAL, 0) +} + +func (s *TableOptionPageCompressedContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *TableOptionPageCompressedContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTableOptionPageCompressed(s) + } +} + +func (s *TableOptionPageCompressedContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTableOptionPageCompressed(s) + } +} + +type TableOptionStartTransactionContext struct { + TableOptionContext +} + +func NewTableOptionStartTransactionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionStartTransactionContext { + var p = new(TableOptionStartTransactionContext) + + InitEmptyTableOptionContext(&p.TableOptionContext) + p.parser = parser + p.CopyAll(ctx.(*TableOptionContext)) + + return p +} + +func (s *TableOptionStartTransactionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableOptionStartTransactionContext) START() antlr.TerminalNode { + return s.GetToken(MySqlParserSTART, 0) +} + +func (s *TableOptionStartTransactionContext) TRANSACTION() antlr.TerminalNode { + return s.GetToken(MySqlParserTRANSACTION, 0) +} + +func (s *TableOptionStartTransactionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTableOptionStartTransaction(s) + } +} + +func (s *TableOptionStartTransactionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTableOptionStartTransaction(s) + } +} + +type TableOptionPackKeysContext struct { + TableOptionContext + extBoolValue antlr.Token +} + +func NewTableOptionPackKeysContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionPackKeysContext { + var p = new(TableOptionPackKeysContext) + + InitEmptyTableOptionContext(&p.TableOptionContext) + p.parser = parser + p.CopyAll(ctx.(*TableOptionContext)) + + return p +} + +func (s *TableOptionPackKeysContext) GetExtBoolValue() antlr.Token { return s.extBoolValue } + +func (s *TableOptionPackKeysContext) SetExtBoolValue(v antlr.Token) { s.extBoolValue = v } + +func (s *TableOptionPackKeysContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableOptionPackKeysContext) PACK_KEYS() antlr.TerminalNode { + return s.GetToken(MySqlParserPACK_KEYS, 0) +} + +func (s *TableOptionPackKeysContext) ZERO_DECIMAL() antlr.TerminalNode { + return s.GetToken(MySqlParserZERO_DECIMAL, 0) +} + +func (s *TableOptionPackKeysContext) ONE_DECIMAL() antlr.TerminalNode { + return s.GetToken(MySqlParserONE_DECIMAL, 0) +} + +func (s *TableOptionPackKeysContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(MySqlParserDEFAULT, 0) +} + +func (s *TableOptionPackKeysContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *TableOptionPackKeysContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTableOptionPackKeys(s) + } +} + +func (s *TableOptionPackKeysContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTableOptionPackKeys(s) + } +} + +type TableOptionPasswordContext struct { + TableOptionContext +} + +func NewTableOptionPasswordContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionPasswordContext { + var p = new(TableOptionPasswordContext) + + InitEmptyTableOptionContext(&p.TableOptionContext) + p.parser = parser + p.CopyAll(ctx.(*TableOptionContext)) + + return p +} + +func (s *TableOptionPasswordContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableOptionPasswordContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(MySqlParserPASSWORD, 0) +} + +func (s *TableOptionPasswordContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *TableOptionPasswordContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *TableOptionPasswordContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTableOptionPassword(s) + } +} + +func (s *TableOptionPasswordContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTableOptionPassword(s) + } +} + +type TableOptionUnionContext struct { + TableOptionContext +} + +func NewTableOptionUnionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionUnionContext { + var p = new(TableOptionUnionContext) + + InitEmptyTableOptionContext(&p.TableOptionContext) + p.parser = parser + p.CopyAll(ctx.(*TableOptionContext)) + + return p +} + +func (s *TableOptionUnionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableOptionUnionContext) UNION() antlr.TerminalNode { + return s.GetToken(MySqlParserUNION, 0) +} + +func (s *TableOptionUnionContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *TableOptionUnionContext) Tables() ITablesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablesContext) +} + +func (s *TableOptionUnionContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *TableOptionUnionContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *TableOptionUnionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTableOptionUnion(s) + } +} + +func (s *TableOptionUnionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTableOptionUnion(s) + } +} + +type TableOptionSamplePageContext struct { + TableOptionContext +} + +func NewTableOptionSamplePageContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionSamplePageContext { + var p = new(TableOptionSamplePageContext) + + InitEmptyTableOptionContext(&p.TableOptionContext) + p.parser = parser + p.CopyAll(ctx.(*TableOptionContext)) + + return p +} + +func (s *TableOptionSamplePageContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableOptionSamplePageContext) STATS_SAMPLE_PAGES() antlr.TerminalNode { + return s.GetToken(MySqlParserSTATS_SAMPLE_PAGES, 0) +} + +func (s *TableOptionSamplePageContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(MySqlParserDEFAULT, 0) +} + +func (s *TableOptionSamplePageContext) DecimalLiteral() IDecimalLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *TableOptionSamplePageContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *TableOptionSamplePageContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTableOptionSamplePage(s) + } +} + +func (s *TableOptionSamplePageContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTableOptionSamplePage(s) + } +} + +type TableOptionCharsetContext struct { + TableOptionContext +} + +func NewTableOptionCharsetContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionCharsetContext { + var p = new(TableOptionCharsetContext) + + InitEmptyTableOptionContext(&p.TableOptionContext) + p.parser = parser + p.CopyAll(ctx.(*TableOptionContext)) + + return p +} + +func (s *TableOptionCharsetContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableOptionCharsetContext) CharSet() ICharSetContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICharSetContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICharSetContext) +} + +func (s *TableOptionCharsetContext) CharsetName() ICharsetNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICharsetNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICharsetNameContext) +} + +func (s *TableOptionCharsetContext) AllDEFAULT() []antlr.TerminalNode { + return s.GetTokens(MySqlParserDEFAULT) +} + +func (s *TableOptionCharsetContext) DEFAULT(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserDEFAULT, i) +} + +func (s *TableOptionCharsetContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *TableOptionCharsetContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTableOptionCharset(s) + } +} + +func (s *TableOptionCharsetContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTableOptionCharset(s) + } +} + +type TableOptionIndexDirectoryContext struct { + TableOptionContext +} + +func NewTableOptionIndexDirectoryContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionIndexDirectoryContext { + var p = new(TableOptionIndexDirectoryContext) + + InitEmptyTableOptionContext(&p.TableOptionContext) + p.parser = parser + p.CopyAll(ctx.(*TableOptionContext)) + + return p +} + +func (s *TableOptionIndexDirectoryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableOptionIndexDirectoryContext) INDEX() antlr.TerminalNode { + return s.GetToken(MySqlParserINDEX, 0) +} + +func (s *TableOptionIndexDirectoryContext) DIRECTORY() antlr.TerminalNode { + return s.GetToken(MySqlParserDIRECTORY, 0) +} + +func (s *TableOptionIndexDirectoryContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *TableOptionIndexDirectoryContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *TableOptionIndexDirectoryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTableOptionIndexDirectory(s) + } +} + +func (s *TableOptionIndexDirectoryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTableOptionIndexDirectory(s) + } +} + +type TableOptionTableTypeContext struct { + TableOptionContext +} + +func NewTableOptionTableTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionTableTypeContext { + var p = new(TableOptionTableTypeContext) + + InitEmptyTableOptionContext(&p.TableOptionContext) + p.parser = parser + p.CopyAll(ctx.(*TableOptionContext)) + + return p +} + +func (s *TableOptionTableTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableOptionTableTypeContext) TABLE_TYPE() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLE_TYPE, 0) +} + +func (s *TableOptionTableTypeContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *TableOptionTableTypeContext) TableType() ITableTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableTypeContext) +} + +func (s *TableOptionTableTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTableOptionTableType(s) + } +} + +func (s *TableOptionTableTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTableOptionTableType(s) + } +} + +type TableOptionKeyBlockSizeContext struct { + TableOptionContext +} + +func NewTableOptionKeyBlockSizeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionKeyBlockSizeContext { + var p = new(TableOptionKeyBlockSizeContext) + + InitEmptyTableOptionContext(&p.TableOptionContext) + p.parser = parser + p.CopyAll(ctx.(*TableOptionContext)) + + return p +} + +func (s *TableOptionKeyBlockSizeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableOptionKeyBlockSizeContext) KEY_BLOCK_SIZE() antlr.TerminalNode { + return s.GetToken(MySqlParserKEY_BLOCK_SIZE, 0) +} + +func (s *TableOptionKeyBlockSizeContext) FileSizeLiteral() IFileSizeLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFileSizeLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFileSizeLiteralContext) +} + +func (s *TableOptionKeyBlockSizeContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *TableOptionKeyBlockSizeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTableOptionKeyBlockSize(s) + } +} + +func (s *TableOptionKeyBlockSizeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTableOptionKeyBlockSize(s) + } +} + +type TableOptionEncryptionContext struct { + TableOptionContext +} + +func NewTableOptionEncryptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionEncryptionContext { + var p = new(TableOptionEncryptionContext) + + InitEmptyTableOptionContext(&p.TableOptionContext) + p.parser = parser + p.CopyAll(ctx.(*TableOptionContext)) + + return p +} + +func (s *TableOptionEncryptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableOptionEncryptionContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(MySqlParserENCRYPTION, 0) +} + +func (s *TableOptionEncryptionContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *TableOptionEncryptionContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *TableOptionEncryptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTableOptionEncryption(s) + } +} + +func (s *TableOptionEncryptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTableOptionEncryption(s) + } +} + +type TableOptionDataDirectoryContext struct { + TableOptionContext +} + +func NewTableOptionDataDirectoryContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionDataDirectoryContext { + var p = new(TableOptionDataDirectoryContext) + + InitEmptyTableOptionContext(&p.TableOptionContext) + p.parser = parser + p.CopyAll(ctx.(*TableOptionContext)) + + return p +} + +func (s *TableOptionDataDirectoryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableOptionDataDirectoryContext) DIRECTORY() antlr.TerminalNode { + return s.GetToken(MySqlParserDIRECTORY, 0) +} + +func (s *TableOptionDataDirectoryContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *TableOptionDataDirectoryContext) DATA() antlr.TerminalNode { + return s.GetToken(MySqlParserDATA, 0) +} + +func (s *TableOptionDataDirectoryContext) INDEX() antlr.TerminalNode { + return s.GetToken(MySqlParserINDEX, 0) +} + +func (s *TableOptionDataDirectoryContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *TableOptionDataDirectoryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTableOptionDataDirectory(s) + } +} + +func (s *TableOptionDataDirectoryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTableOptionDataDirectory(s) + } +} + +type TableOptionRecalculationContext struct { + TableOptionContext + extBoolValue antlr.Token +} + +func NewTableOptionRecalculationContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionRecalculationContext { + var p = new(TableOptionRecalculationContext) + + InitEmptyTableOptionContext(&p.TableOptionContext) + p.parser = parser + p.CopyAll(ctx.(*TableOptionContext)) + + return p +} + +func (s *TableOptionRecalculationContext) GetExtBoolValue() antlr.Token { return s.extBoolValue } + +func (s *TableOptionRecalculationContext) SetExtBoolValue(v antlr.Token) { s.extBoolValue = v } + +func (s *TableOptionRecalculationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableOptionRecalculationContext) STATS_AUTO_RECALC() antlr.TerminalNode { + return s.GetToken(MySqlParserSTATS_AUTO_RECALC, 0) +} + +func (s *TableOptionRecalculationContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(MySqlParserDEFAULT, 0) +} + +func (s *TableOptionRecalculationContext) ZERO_DECIMAL() antlr.TerminalNode { + return s.GetToken(MySqlParserZERO_DECIMAL, 0) +} + +func (s *TableOptionRecalculationContext) ONE_DECIMAL() antlr.TerminalNode { + return s.GetToken(MySqlParserONE_DECIMAL, 0) +} + +func (s *TableOptionRecalculationContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *TableOptionRecalculationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTableOptionRecalculation(s) + } +} + +func (s *TableOptionRecalculationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTableOptionRecalculation(s) + } +} + +type TableOptionAutoIncrementContext struct { + TableOptionContext +} + +func NewTableOptionAutoIncrementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionAutoIncrementContext { + var p = new(TableOptionAutoIncrementContext) + + InitEmptyTableOptionContext(&p.TableOptionContext) + p.parser = parser + p.CopyAll(ctx.(*TableOptionContext)) + + return p +} + +func (s *TableOptionAutoIncrementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableOptionAutoIncrementContext) AUTO_INCREMENT() antlr.TerminalNode { + return s.GetToken(MySqlParserAUTO_INCREMENT, 0) +} + +func (s *TableOptionAutoIncrementContext) DecimalLiteral() IDecimalLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *TableOptionAutoIncrementContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *TableOptionAutoIncrementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTableOptionAutoIncrement(s) + } +} + +func (s *TableOptionAutoIncrementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTableOptionAutoIncrement(s) + } +} + +type TableOptionEncryptionKeyIdContext struct { + TableOptionContext +} + +func NewTableOptionEncryptionKeyIdContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionEncryptionKeyIdContext { + var p = new(TableOptionEncryptionKeyIdContext) + + InitEmptyTableOptionContext(&p.TableOptionContext) + p.parser = parser + p.CopyAll(ctx.(*TableOptionContext)) + + return p +} + +func (s *TableOptionEncryptionKeyIdContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableOptionEncryptionKeyIdContext) ENCRYPTION_KEY_ID() antlr.TerminalNode { + return s.GetToken(MySqlParserENCRYPTION_KEY_ID, 0) +} + +func (s *TableOptionEncryptionKeyIdContext) DecimalLiteral() IDecimalLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *TableOptionEncryptionKeyIdContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *TableOptionEncryptionKeyIdContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTableOptionEncryptionKeyId(s) + } +} + +func (s *TableOptionEncryptionKeyIdContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTableOptionEncryptionKeyId(s) + } +} + +type TableOptionChecksumContext struct { + TableOptionContext + boolValue antlr.Token +} + +func NewTableOptionChecksumContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionChecksumContext { + var p = new(TableOptionChecksumContext) + + InitEmptyTableOptionContext(&p.TableOptionContext) + p.parser = parser + p.CopyAll(ctx.(*TableOptionContext)) + + return p +} + +func (s *TableOptionChecksumContext) GetBoolValue() antlr.Token { return s.boolValue } + +func (s *TableOptionChecksumContext) SetBoolValue(v antlr.Token) { s.boolValue = v } + +func (s *TableOptionChecksumContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableOptionChecksumContext) CHECKSUM() antlr.TerminalNode { + return s.GetToken(MySqlParserCHECKSUM, 0) +} + +func (s *TableOptionChecksumContext) PAGE_CHECKSUM() antlr.TerminalNode { + return s.GetToken(MySqlParserPAGE_CHECKSUM, 0) +} + +func (s *TableOptionChecksumContext) ZERO_DECIMAL() antlr.TerminalNode { + return s.GetToken(MySqlParserZERO_DECIMAL, 0) +} + +func (s *TableOptionChecksumContext) ONE_DECIMAL() antlr.TerminalNode { + return s.GetToken(MySqlParserONE_DECIMAL, 0) +} + +func (s *TableOptionChecksumContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *TableOptionChecksumContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTableOptionChecksum(s) + } +} + +func (s *TableOptionChecksumContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTableOptionChecksum(s) + } +} + +type TableOptionDelayContext struct { + TableOptionContext + boolValue antlr.Token +} + +func NewTableOptionDelayContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionDelayContext { + var p = new(TableOptionDelayContext) + + InitEmptyTableOptionContext(&p.TableOptionContext) + p.parser = parser + p.CopyAll(ctx.(*TableOptionContext)) + + return p +} + +func (s *TableOptionDelayContext) GetBoolValue() antlr.Token { return s.boolValue } + +func (s *TableOptionDelayContext) SetBoolValue(v antlr.Token) { s.boolValue = v } + +func (s *TableOptionDelayContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableOptionDelayContext) DELAY_KEY_WRITE() antlr.TerminalNode { + return s.GetToken(MySqlParserDELAY_KEY_WRITE, 0) +} + +func (s *TableOptionDelayContext) ZERO_DECIMAL() antlr.TerminalNode { + return s.GetToken(MySqlParserZERO_DECIMAL, 0) +} + +func (s *TableOptionDelayContext) ONE_DECIMAL() antlr.TerminalNode { + return s.GetToken(MySqlParserONE_DECIMAL, 0) +} + +func (s *TableOptionDelayContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *TableOptionDelayContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTableOptionDelay(s) + } +} + +func (s *TableOptionDelayContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTableOptionDelay(s) + } +} + +type TableOptionConnectionContext struct { + TableOptionContext +} + +func NewTableOptionConnectionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionConnectionContext { + var p = new(TableOptionConnectionContext) + + InitEmptyTableOptionContext(&p.TableOptionContext) + p.parser = parser + p.CopyAll(ctx.(*TableOptionContext)) + + return p +} + +func (s *TableOptionConnectionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableOptionConnectionContext) CONNECTION() antlr.TerminalNode { + return s.GetToken(MySqlParserCONNECTION, 0) +} + +func (s *TableOptionConnectionContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *TableOptionConnectionContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *TableOptionConnectionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTableOptionConnection(s) + } +} + +func (s *TableOptionConnectionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTableOptionConnection(s) + } +} + +type TableOptionTransactionalContext struct { + TableOptionContext +} + +func NewTableOptionTransactionalContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionTransactionalContext { + var p = new(TableOptionTransactionalContext) + + InitEmptyTableOptionContext(&p.TableOptionContext) + p.parser = parser + p.CopyAll(ctx.(*TableOptionContext)) + + return p +} + +func (s *TableOptionTransactionalContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableOptionTransactionalContext) TRANSACTIONAL() antlr.TerminalNode { + return s.GetToken(MySqlParserTRANSACTIONAL, 0) +} + +func (s *TableOptionTransactionalContext) ZERO_DECIMAL() antlr.TerminalNode { + return s.GetToken(MySqlParserZERO_DECIMAL, 0) +} + +func (s *TableOptionTransactionalContext) ONE_DECIMAL() antlr.TerminalNode { + return s.GetToken(MySqlParserONE_DECIMAL, 0) +} + +func (s *TableOptionTransactionalContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *TableOptionTransactionalContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTableOptionTransactional(s) + } +} + +func (s *TableOptionTransactionalContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTableOptionTransactional(s) + } +} + +type TableOptionPageCompressionLevelContext struct { + TableOptionContext +} + +func NewTableOptionPageCompressionLevelContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionPageCompressionLevelContext { + var p = new(TableOptionPageCompressionLevelContext) + + InitEmptyTableOptionContext(&p.TableOptionContext) + p.parser = parser + p.CopyAll(ctx.(*TableOptionContext)) + + return p +} + +func (s *TableOptionPageCompressionLevelContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableOptionPageCompressionLevelContext) DecimalLiteral() IDecimalLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *TableOptionPageCompressionLevelContext) PAGE_COMPRESSION_LEVEL() antlr.TerminalNode { + return s.GetToken(MySqlParserPAGE_COMPRESSION_LEVEL, 0) +} + +func (s *TableOptionPageCompressionLevelContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *TableOptionPageCompressionLevelContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *TableOptionPageCompressionLevelContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTableOptionPageCompressionLevel(s) + } +} + +func (s *TableOptionPageCompressionLevelContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTableOptionPageCompressionLevel(s) + } +} + +type TableOptionSecondaryEngineAttributeContext struct { + TableOptionContext +} + +func NewTableOptionSecondaryEngineAttributeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionSecondaryEngineAttributeContext { + var p = new(TableOptionSecondaryEngineAttributeContext) + + InitEmptyTableOptionContext(&p.TableOptionContext) + p.parser = parser + p.CopyAll(ctx.(*TableOptionContext)) + + return p +} + +func (s *TableOptionSecondaryEngineAttributeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableOptionSecondaryEngineAttributeContext) SECONDARY_ENGINE_ATTRIBUTE() antlr.TerminalNode { + return s.GetToken(MySqlParserSECONDARY_ENGINE_ATTRIBUTE, 0) +} + +func (s *TableOptionSecondaryEngineAttributeContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *TableOptionSecondaryEngineAttributeContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *TableOptionSecondaryEngineAttributeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTableOptionSecondaryEngineAttribute(s) + } +} + +func (s *TableOptionSecondaryEngineAttributeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTableOptionSecondaryEngineAttribute(s) + } +} + +type TableOptionCommentContext struct { + TableOptionContext +} + +func NewTableOptionCommentContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionCommentContext { + var p = new(TableOptionCommentContext) + + InitEmptyTableOptionContext(&p.TableOptionContext) + p.parser = parser + p.CopyAll(ctx.(*TableOptionContext)) + + return p +} + +func (s *TableOptionCommentContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableOptionCommentContext) COMMENT() antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMENT, 0) +} + +func (s *TableOptionCommentContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *TableOptionCommentContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *TableOptionCommentContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTableOptionComment(s) + } +} + +func (s *TableOptionCommentContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTableOptionComment(s) + } +} + +type TableOptionAverageContext struct { + TableOptionContext +} + +func NewTableOptionAverageContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionAverageContext { + var p = new(TableOptionAverageContext) + + InitEmptyTableOptionContext(&p.TableOptionContext) + p.parser = parser + p.CopyAll(ctx.(*TableOptionContext)) + + return p +} + +func (s *TableOptionAverageContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableOptionAverageContext) AVG_ROW_LENGTH() antlr.TerminalNode { + return s.GetToken(MySqlParserAVG_ROW_LENGTH, 0) +} + +func (s *TableOptionAverageContext) DecimalLiteral() IDecimalLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *TableOptionAverageContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *TableOptionAverageContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTableOptionAverage(s) + } +} + +func (s *TableOptionAverageContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTableOptionAverage(s) + } +} + +type TableOptionRowFormatContext struct { + TableOptionContext + rowFormat antlr.Token +} + +func NewTableOptionRowFormatContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionRowFormatContext { + var p = new(TableOptionRowFormatContext) + + InitEmptyTableOptionContext(&p.TableOptionContext) + p.parser = parser + p.CopyAll(ctx.(*TableOptionContext)) + + return p +} + +func (s *TableOptionRowFormatContext) GetRowFormat() antlr.Token { return s.rowFormat } + +func (s *TableOptionRowFormatContext) SetRowFormat(v antlr.Token) { s.rowFormat = v } + +func (s *TableOptionRowFormatContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableOptionRowFormatContext) ROW_FORMAT() antlr.TerminalNode { + return s.GetToken(MySqlParserROW_FORMAT, 0) +} + +func (s *TableOptionRowFormatContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(MySqlParserDEFAULT, 0) +} + +func (s *TableOptionRowFormatContext) DYNAMIC() antlr.TerminalNode { + return s.GetToken(MySqlParserDYNAMIC, 0) +} + +func (s *TableOptionRowFormatContext) FIXED() antlr.TerminalNode { + return s.GetToken(MySqlParserFIXED, 0) +} + +func (s *TableOptionRowFormatContext) COMPRESSED() antlr.TerminalNode { + return s.GetToken(MySqlParserCOMPRESSED, 0) +} + +func (s *TableOptionRowFormatContext) REDUNDANT() antlr.TerminalNode { + return s.GetToken(MySqlParserREDUNDANT, 0) +} + +func (s *TableOptionRowFormatContext) COMPACT() antlr.TerminalNode { + return s.GetToken(MySqlParserCOMPACT, 0) +} + +func (s *TableOptionRowFormatContext) ID() antlr.TerminalNode { + return s.GetToken(MySqlParserID, 0) +} + +func (s *TableOptionRowFormatContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *TableOptionRowFormatContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTableOptionRowFormat(s) + } +} + +func (s *TableOptionRowFormatContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTableOptionRowFormat(s) + } +} + +type TableOptionCompressionContext struct { + TableOptionContext +} + +func NewTableOptionCompressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionCompressionContext { + var p = new(TableOptionCompressionContext) + + InitEmptyTableOptionContext(&p.TableOptionContext) + p.parser = parser + p.CopyAll(ctx.(*TableOptionContext)) + + return p +} + +func (s *TableOptionCompressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableOptionCompressionContext) COMPRESSION() antlr.TerminalNode { + return s.GetToken(MySqlParserCOMPRESSION, 0) +} + +func (s *TableOptionCompressionContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *TableOptionCompressionContext) ID() antlr.TerminalNode { + return s.GetToken(MySqlParserID, 0) +} + +func (s *TableOptionCompressionContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *TableOptionCompressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTableOptionCompression(s) + } +} + +func (s *TableOptionCompressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTableOptionCompression(s) + } +} + +type TableOptionInsertMethodContext struct { + TableOptionContext + insertMethod antlr.Token +} + +func NewTableOptionInsertMethodContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionInsertMethodContext { + var p = new(TableOptionInsertMethodContext) + + InitEmptyTableOptionContext(&p.TableOptionContext) + p.parser = parser + p.CopyAll(ctx.(*TableOptionContext)) + + return p +} + +func (s *TableOptionInsertMethodContext) GetInsertMethod() antlr.Token { return s.insertMethod } + +func (s *TableOptionInsertMethodContext) SetInsertMethod(v antlr.Token) { s.insertMethod = v } + +func (s *TableOptionInsertMethodContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableOptionInsertMethodContext) INSERT_METHOD() antlr.TerminalNode { + return s.GetToken(MySqlParserINSERT_METHOD, 0) +} + +func (s *TableOptionInsertMethodContext) NO() antlr.TerminalNode { + return s.GetToken(MySqlParserNO, 0) +} + +func (s *TableOptionInsertMethodContext) FIRST() antlr.TerminalNode { + return s.GetToken(MySqlParserFIRST, 0) +} + +func (s *TableOptionInsertMethodContext) LAST() antlr.TerminalNode { + return s.GetToken(MySqlParserLAST, 0) +} + +func (s *TableOptionInsertMethodContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *TableOptionInsertMethodContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTableOptionInsertMethod(s) + } +} + +func (s *TableOptionInsertMethodContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTableOptionInsertMethod(s) + } +} + +type TableOptionEngineAttributeContext struct { + TableOptionContext +} + +func NewTableOptionEngineAttributeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionEngineAttributeContext { + var p = new(TableOptionEngineAttributeContext) + + InitEmptyTableOptionContext(&p.TableOptionContext) + p.parser = parser + p.CopyAll(ctx.(*TableOptionContext)) + + return p +} + +func (s *TableOptionEngineAttributeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableOptionEngineAttributeContext) ENGINE_ATTRIBUTE() antlr.TerminalNode { + return s.GetToken(MySqlParserENGINE_ATTRIBUTE, 0) +} + +func (s *TableOptionEngineAttributeContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *TableOptionEngineAttributeContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *TableOptionEngineAttributeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTableOptionEngineAttribute(s) + } +} + +func (s *TableOptionEngineAttributeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTableOptionEngineAttribute(s) + } +} + +type TableOptionMinRowsContext struct { + TableOptionContext +} + +func NewTableOptionMinRowsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableOptionMinRowsContext { + var p = new(TableOptionMinRowsContext) + + InitEmptyTableOptionContext(&p.TableOptionContext) + p.parser = parser + p.CopyAll(ctx.(*TableOptionContext)) + + return p +} + +func (s *TableOptionMinRowsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableOptionMinRowsContext) MIN_ROWS() antlr.TerminalNode { + return s.GetToken(MySqlParserMIN_ROWS, 0) +} + +func (s *TableOptionMinRowsContext) DecimalLiteral() IDecimalLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *TableOptionMinRowsContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *TableOptionMinRowsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTableOptionMinRows(s) + } +} + +func (s *TableOptionMinRowsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTableOptionMinRows(s) + } +} + +func (p *MySqlParser) TableOption() (localctx ITableOptionContext) { + localctx = NewTableOptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 106, MySqlParserRULE_tableOption) + var _la int + + p.SetState(2009) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 228, p.GetParserRuleContext()) { + case 1: + localctx = NewTableOptionEngineContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1824) + p.Match(MySqlParserENGINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1826) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1825) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(1829) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 192, p.GetParserRuleContext()) == 1 { + { + p.SetState(1828) + p.EngineName() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + localctx = NewTableOptionEngineAttributeContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1831) + p.Match(MySqlParserENGINE_ATTRIBUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1833) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1832) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1835) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + localctx = NewTableOptionAutoextendSizeContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1836) + p.Match(MySqlParserAUTOEXTEND_SIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1838) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1837) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1840) + p.DecimalLiteral() + } + + case 4: + localctx = NewTableOptionAutoIncrementContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(1841) + p.Match(MySqlParserAUTO_INCREMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1843) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1842) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1845) + p.DecimalLiteral() + } + + case 5: + localctx = NewTableOptionAverageContext(p, localctx) + p.EnterOuterAlt(localctx, 5) + { + p.SetState(1846) + p.Match(MySqlParserAVG_ROW_LENGTH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1848) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1847) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1850) + p.DecimalLiteral() + } + + case 6: + localctx = NewTableOptionCharsetContext(p, localctx) + p.EnterOuterAlt(localctx, 6) + p.SetState(1852) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserDEFAULT { + { + p.SetState(1851) + p.Match(MySqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1854) + p.CharSet() + } + p.SetState(1856) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1855) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(1860) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserBINARY, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserCHARSET_REVERSE_QOUTE_STRING, MySqlParserSTRING_LITERAL: + { + p.SetState(1858) + p.CharsetName() + } + + case MySqlParserDEFAULT: + { + p.SetState(1859) + p.Match(MySqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 7: + localctx = NewTableOptionChecksumContext(p, localctx) + p.EnterOuterAlt(localctx, 7) + { + p.SetState(1862) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserCHECKSUM || _la == MySqlParserPAGE_CHECKSUM) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(1864) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1863) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1866) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*TableOptionChecksumContext).boolValue = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserZERO_DECIMAL || _la == MySqlParserONE_DECIMAL) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*TableOptionChecksumContext).boolValue = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 8: + localctx = NewTableOptionCollateContext(p, localctx) + p.EnterOuterAlt(localctx, 8) + p.SetState(1868) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserDEFAULT { + { + p.SetState(1867) + p.Match(MySqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1870) + p.Match(MySqlParserCOLLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1872) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1871) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1874) + p.CollationName() + } + + case 9: + localctx = NewTableOptionCommentContext(p, localctx) + p.EnterOuterAlt(localctx, 9) + { + p.SetState(1875) + p.Match(MySqlParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1877) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1876) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1879) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 10: + localctx = NewTableOptionCompressionContext(p, localctx) + p.EnterOuterAlt(localctx, 10) + { + p.SetState(1880) + p.Match(MySqlParserCOMPRESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1882) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1881) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1884) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserSTRING_LITERAL || _la == MySqlParserID) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 11: + localctx = NewTableOptionConnectionContext(p, localctx) + p.EnterOuterAlt(localctx, 11) + { + p.SetState(1885) + p.Match(MySqlParserCONNECTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1887) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1886) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1889) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 12: + localctx = NewTableOptionDataDirectoryContext(p, localctx) + p.EnterOuterAlt(localctx, 12) + { + p.SetState(1890) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserINDEX || _la == MySqlParserDATA) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(1891) + p.Match(MySqlParserDIRECTORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1893) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1892) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1895) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 13: + localctx = NewTableOptionDelayContext(p, localctx) + p.EnterOuterAlt(localctx, 13) + { + p.SetState(1896) + p.Match(MySqlParserDELAY_KEY_WRITE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1898) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1897) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1900) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*TableOptionDelayContext).boolValue = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserZERO_DECIMAL || _la == MySqlParserONE_DECIMAL) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*TableOptionDelayContext).boolValue = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 14: + localctx = NewTableOptionEncryptionContext(p, localctx) + p.EnterOuterAlt(localctx, 14) + { + p.SetState(1901) + p.Match(MySqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1903) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1902) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1905) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 15: + localctx = NewTableOptionPageCompressedContext(p, localctx) + p.EnterOuterAlt(localctx, 15) + { + p.SetState(1906) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserPAGE_COMPRESSED || _la == MySqlParserSTRING_LITERAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(1908) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1907) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1910) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserZERO_DECIMAL || _la == MySqlParserONE_DECIMAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 16: + localctx = NewTableOptionPageCompressionLevelContext(p, localctx) + p.EnterOuterAlt(localctx, 16) + { + p.SetState(1911) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserPAGE_COMPRESSION_LEVEL || _la == MySqlParserSTRING_LITERAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(1913) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1912) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1915) + p.DecimalLiteral() + } + + case 17: + localctx = NewTableOptionEncryptionKeyIdContext(p, localctx) + p.EnterOuterAlt(localctx, 17) + { + p.SetState(1916) + p.Match(MySqlParserENCRYPTION_KEY_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1918) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1917) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1920) + p.DecimalLiteral() + } + + case 18: + localctx = NewTableOptionIndexDirectoryContext(p, localctx) + p.EnterOuterAlt(localctx, 18) + { + p.SetState(1921) + p.Match(MySqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1922) + p.Match(MySqlParserDIRECTORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1924) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1923) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1926) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 19: + localctx = NewTableOptionInsertMethodContext(p, localctx) + p.EnterOuterAlt(localctx, 19) + { + p.SetState(1927) + p.Match(MySqlParserINSERT_METHOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1929) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1928) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1931) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*TableOptionInsertMethodContext).insertMethod = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserFIRST || _la == MySqlParserLAST || _la == MySqlParserNO) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*TableOptionInsertMethodContext).insertMethod = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 20: + localctx = NewTableOptionKeyBlockSizeContext(p, localctx) + p.EnterOuterAlt(localctx, 20) + { + p.SetState(1932) + p.Match(MySqlParserKEY_BLOCK_SIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1934) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1933) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1936) + p.FileSizeLiteral() + } + + case 21: + localctx = NewTableOptionMaxRowsContext(p, localctx) + p.EnterOuterAlt(localctx, 21) + { + p.SetState(1937) + p.Match(MySqlParserMAX_ROWS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1939) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1938) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1941) + p.DecimalLiteral() + } + + case 22: + localctx = NewTableOptionMinRowsContext(p, localctx) + p.EnterOuterAlt(localctx, 22) + { + p.SetState(1942) + p.Match(MySqlParserMIN_ROWS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1944) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1943) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1946) + p.DecimalLiteral() + } + + case 23: + localctx = NewTableOptionPackKeysContext(p, localctx) + p.EnterOuterAlt(localctx, 23) + { + p.SetState(1947) + p.Match(MySqlParserPACK_KEYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1949) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1948) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1951) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*TableOptionPackKeysContext).extBoolValue = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserDEFAULT || _la == MySqlParserZERO_DECIMAL || _la == MySqlParserONE_DECIMAL) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*TableOptionPackKeysContext).extBoolValue = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 24: + localctx = NewTableOptionPasswordContext(p, localctx) + p.EnterOuterAlt(localctx, 24) + { + p.SetState(1952) + p.Match(MySqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1954) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1953) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1956) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 25: + localctx = NewTableOptionRowFormatContext(p, localctx) + p.EnterOuterAlt(localctx, 25) + { + p.SetState(1957) + p.Match(MySqlParserROW_FORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1959) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1958) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1961) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*TableOptionRowFormatContext).rowFormat = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserDEFAULT || ((int64((_la-371)) & ^0x3f) == 0 && ((int64(1)<<(_la-371))&2305843013508661253) != 0) || _la == MySqlParserREDUNDANT || _la == MySqlParserID) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*TableOptionRowFormatContext).rowFormat = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 26: + localctx = NewTableOptionStartTransactionContext(p, localctx) + p.EnterOuterAlt(localctx, 26) + { + p.SetState(1962) + p.Match(MySqlParserSTART) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1963) + p.Match(MySqlParserTRANSACTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 27: + localctx = NewTableOptionSecondaryEngineAttributeContext(p, localctx) + p.EnterOuterAlt(localctx, 27) + { + p.SetState(1964) + p.Match(MySqlParserSECONDARY_ENGINE_ATTRIBUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1966) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1965) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1968) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 28: + localctx = NewTableOptionRecalculationContext(p, localctx) + p.EnterOuterAlt(localctx, 28) + { + p.SetState(1969) + p.Match(MySqlParserSTATS_AUTO_RECALC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1971) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1970) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1973) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*TableOptionRecalculationContext).extBoolValue = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserDEFAULT || _la == MySqlParserZERO_DECIMAL || _la == MySqlParserONE_DECIMAL) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*TableOptionRecalculationContext).extBoolValue = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 29: + localctx = NewTableOptionPersistentContext(p, localctx) + p.EnterOuterAlt(localctx, 29) + { + p.SetState(1974) + p.Match(MySqlParserSTATS_PERSISTENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1976) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1975) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1978) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*TableOptionPersistentContext).extBoolValue = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserDEFAULT || _la == MySqlParserZERO_DECIMAL || _la == MySqlParserONE_DECIMAL) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*TableOptionPersistentContext).extBoolValue = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 30: + localctx = NewTableOptionSamplePageContext(p, localctx) + p.EnterOuterAlt(localctx, 30) + { + p.SetState(1979) + p.Match(MySqlParserSTATS_SAMPLE_PAGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1981) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1980) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(1985) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserDEFAULT: + { + p.SetState(1983) + p.Match(MySqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserZERO_DECIMAL, MySqlParserONE_DECIMAL, MySqlParserTWO_DECIMAL, MySqlParserDECIMAL_LITERAL, MySqlParserREAL_LITERAL: + { + p.SetState(1984) + p.DecimalLiteral() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 31: + localctx = NewTableOptionTablespaceContext(p, localctx) + p.EnterOuterAlt(localctx, 31) + { + p.SetState(1987) + p.Match(MySqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1988) + p.Uid() + } + p.SetState(1990) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 225, p.GetParserRuleContext()) == 1 { + { + p.SetState(1989) + p.TablespaceStorage() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 32: + localctx = NewTableOptionTableTypeContext(p, localctx) + p.EnterOuterAlt(localctx, 32) + { + p.SetState(1992) + p.Match(MySqlParserTABLE_TYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1993) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1994) + p.TableType() + } + + case 33: + localctx = NewTableOptionTablespaceContext(p, localctx) + p.EnterOuterAlt(localctx, 33) + { + p.SetState(1995) + p.TablespaceStorage() + } + + case 34: + localctx = NewTableOptionTransactionalContext(p, localctx) + p.EnterOuterAlt(localctx, 34) + { + p.SetState(1996) + p.Match(MySqlParserTRANSACTIONAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1998) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(1997) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2000) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserZERO_DECIMAL || _la == MySqlParserONE_DECIMAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 35: + localctx = NewTableOptionUnionContext(p, localctx) + p.EnterOuterAlt(localctx, 35) + { + p.SetState(2001) + p.Match(MySqlParserUNION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2003) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(2002) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2005) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2006) + p.Tables() + } + { + p.SetState(2007) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITableTypeContext is an interface to support dynamic dispatch. +type ITableTypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MYSQL() antlr.TerminalNode + ODBC() antlr.TerminalNode + + // IsTableTypeContext differentiates from other interfaces. + IsTableTypeContext() +} + +type TableTypeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTableTypeContext() *TableTypeContext { + var p = new(TableTypeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_tableType + return p +} + +func InitEmptyTableTypeContext(p *TableTypeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_tableType +} + +func (*TableTypeContext) IsTableTypeContext() {} + +func NewTableTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableTypeContext { + var p = new(TableTypeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_tableType + + return p +} + +func (s *TableTypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *TableTypeContext) MYSQL() antlr.TerminalNode { + return s.GetToken(MySqlParserMYSQL, 0) +} + +func (s *TableTypeContext) ODBC() antlr.TerminalNode { + return s.GetToken(MySqlParserODBC, 0) +} + +func (s *TableTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TableTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTableType(s) + } +} + +func (s *TableTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTableType(s) + } +} + +func (p *MySqlParser) TableType() (localctx ITableTypeContext) { + localctx = NewTableTypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 108, MySqlParserRULE_tableType) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2011) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserMYSQL || _la == MySqlParserODBC) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITablespaceStorageContext is an interface to support dynamic dispatch. +type ITablespaceStorageContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + STORAGE() antlr.TerminalNode + DISK() antlr.TerminalNode + MEMORY() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + + // IsTablespaceStorageContext differentiates from other interfaces. + IsTablespaceStorageContext() +} + +type TablespaceStorageContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTablespaceStorageContext() *TablespaceStorageContext { + var p = new(TablespaceStorageContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_tablespaceStorage + return p +} + +func InitEmptyTablespaceStorageContext(p *TablespaceStorageContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_tablespaceStorage +} + +func (*TablespaceStorageContext) IsTablespaceStorageContext() {} + +func NewTablespaceStorageContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TablespaceStorageContext { + var p = new(TablespaceStorageContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_tablespaceStorage + + return p +} + +func (s *TablespaceStorageContext) GetParser() antlr.Parser { return s.parser } + +func (s *TablespaceStorageContext) STORAGE() antlr.TerminalNode { + return s.GetToken(MySqlParserSTORAGE, 0) +} + +func (s *TablespaceStorageContext) DISK() antlr.TerminalNode { + return s.GetToken(MySqlParserDISK, 0) +} + +func (s *TablespaceStorageContext) MEMORY() antlr.TerminalNode { + return s.GetToken(MySqlParserMEMORY, 0) +} + +func (s *TablespaceStorageContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(MySqlParserDEFAULT, 0) +} + +func (s *TablespaceStorageContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TablespaceStorageContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TablespaceStorageContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTablespaceStorage(s) + } +} + +func (s *TablespaceStorageContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTablespaceStorage(s) + } +} + +func (p *MySqlParser) TablespaceStorage() (localctx ITablespaceStorageContext) { + localctx = NewTablespaceStorageContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 110, MySqlParserRULE_tablespaceStorage) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2013) + p.Match(MySqlParserSTORAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2014) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserDEFAULT || _la == MySqlParserDISK || _la == MySqlParserMEMORY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPartitionDefinitionsContext is an interface to support dynamic dispatch. +type IPartitionDefinitionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetCount returns the count rule contexts. + GetCount() IDecimalLiteralContext + + // GetSubCount returns the subCount rule contexts. + GetSubCount() IDecimalLiteralContext + + // SetCount sets the count rule contexts. + SetCount(IDecimalLiteralContext) + + // SetSubCount sets the subCount rule contexts. + SetSubCount(IDecimalLiteralContext) + + // Getter signatures + PARTITION() antlr.TerminalNode + AllBY() []antlr.TerminalNode + BY(i int) antlr.TerminalNode + PartitionFunctionDefinition() IPartitionFunctionDefinitionContext + PARTITIONS() antlr.TerminalNode + SUBPARTITION() antlr.TerminalNode + SubpartitionFunctionDefinition() ISubpartitionFunctionDefinitionContext + LR_BRACKET() antlr.TerminalNode + AllPartitionDefinition() []IPartitionDefinitionContext + PartitionDefinition(i int) IPartitionDefinitionContext + RR_BRACKET() antlr.TerminalNode + AllDecimalLiteral() []IDecimalLiteralContext + DecimalLiteral(i int) IDecimalLiteralContext + SUBPARTITIONS() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsPartitionDefinitionsContext differentiates from other interfaces. + IsPartitionDefinitionsContext() +} + +type PartitionDefinitionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + count IDecimalLiteralContext + subCount IDecimalLiteralContext +} + +func NewEmptyPartitionDefinitionsContext() *PartitionDefinitionsContext { + var p = new(PartitionDefinitionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_partitionDefinitions + return p +} + +func InitEmptyPartitionDefinitionsContext(p *PartitionDefinitionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_partitionDefinitions +} + +func (*PartitionDefinitionsContext) IsPartitionDefinitionsContext() {} + +func NewPartitionDefinitionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PartitionDefinitionsContext { + var p = new(PartitionDefinitionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_partitionDefinitions + + return p +} + +func (s *PartitionDefinitionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *PartitionDefinitionsContext) GetCount() IDecimalLiteralContext { return s.count } + +func (s *PartitionDefinitionsContext) GetSubCount() IDecimalLiteralContext { return s.subCount } + +func (s *PartitionDefinitionsContext) SetCount(v IDecimalLiteralContext) { s.count = v } + +func (s *PartitionDefinitionsContext) SetSubCount(v IDecimalLiteralContext) { s.subCount = v } + +func (s *PartitionDefinitionsContext) PARTITION() antlr.TerminalNode { + return s.GetToken(MySqlParserPARTITION, 0) +} + +func (s *PartitionDefinitionsContext) AllBY() []antlr.TerminalNode { + return s.GetTokens(MySqlParserBY) +} + +func (s *PartitionDefinitionsContext) BY(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserBY, i) +} + +func (s *PartitionDefinitionsContext) PartitionFunctionDefinition() IPartitionFunctionDefinitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionFunctionDefinitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartitionFunctionDefinitionContext) +} + +func (s *PartitionDefinitionsContext) PARTITIONS() antlr.TerminalNode { + return s.GetToken(MySqlParserPARTITIONS, 0) +} + +func (s *PartitionDefinitionsContext) SUBPARTITION() antlr.TerminalNode { + return s.GetToken(MySqlParserSUBPARTITION, 0) +} + +func (s *PartitionDefinitionsContext) SubpartitionFunctionDefinition() ISubpartitionFunctionDefinitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartitionFunctionDefinitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartitionFunctionDefinitionContext) +} + +func (s *PartitionDefinitionsContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *PartitionDefinitionsContext) AllPartitionDefinition() []IPartitionDefinitionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPartitionDefinitionContext); ok { + len++ + } + } + + tst := make([]IPartitionDefinitionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPartitionDefinitionContext); ok { + tst[i] = t.(IPartitionDefinitionContext) + i++ + } + } + + return tst +} + +func (s *PartitionDefinitionsContext) PartitionDefinition(i int) IPartitionDefinitionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionDefinitionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPartitionDefinitionContext) +} + +func (s *PartitionDefinitionsContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *PartitionDefinitionsContext) AllDecimalLiteral() []IDecimalLiteralContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDecimalLiteralContext); ok { + len++ + } + } + + tst := make([]IDecimalLiteralContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDecimalLiteralContext); ok { + tst[i] = t.(IDecimalLiteralContext) + i++ + } + } + + return tst +} + +func (s *PartitionDefinitionsContext) DecimalLiteral(i int) IDecimalLiteralContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *PartitionDefinitionsContext) SUBPARTITIONS() antlr.TerminalNode { + return s.GetToken(MySqlParserSUBPARTITIONS, 0) +} + +func (s *PartitionDefinitionsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *PartitionDefinitionsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *PartitionDefinitionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PartitionDefinitionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PartitionDefinitionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterPartitionDefinitions(s) + } +} + +func (s *PartitionDefinitionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitPartitionDefinitions(s) + } +} + +func (p *MySqlParser) PartitionDefinitions() (localctx IPartitionDefinitionsContext) { + localctx = NewPartitionDefinitionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 112, MySqlParserRULE_partitionDefinitions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2016) + p.Match(MySqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2017) + p.Match(MySqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2018) + p.PartitionFunctionDefinition() + } + p.SetState(2021) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserPARTITIONS { + { + p.SetState(2019) + p.Match(MySqlParserPARTITIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2020) + + var _x = p.DecimalLiteral() + + localctx.(*PartitionDefinitionsContext).count = _x + } + + } + p.SetState(2030) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserSUBPARTITION { + { + p.SetState(2023) + p.Match(MySqlParserSUBPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2024) + p.Match(MySqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2025) + p.SubpartitionFunctionDefinition() + } + p.SetState(2028) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserSUBPARTITIONS { + { + p.SetState(2026) + p.Match(MySqlParserSUBPARTITIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2027) + + var _x = p.DecimalLiteral() + + localctx.(*PartitionDefinitionsContext).subCount = _x + } + + } + + } + p.SetState(2043) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 233, p.GetParserRuleContext()) == 1 { + { + p.SetState(2032) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2033) + p.PartitionDefinition() + } + p.SetState(2038) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(2034) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2035) + p.PartitionDefinition() + } + + p.SetState(2040) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2041) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPartitionFunctionDefinitionContext is an interface to support dynamic dispatch. +type IPartitionFunctionDefinitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsPartitionFunctionDefinitionContext differentiates from other interfaces. + IsPartitionFunctionDefinitionContext() +} + +type PartitionFunctionDefinitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPartitionFunctionDefinitionContext() *PartitionFunctionDefinitionContext { + var p = new(PartitionFunctionDefinitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_partitionFunctionDefinition + return p +} + +func InitEmptyPartitionFunctionDefinitionContext(p *PartitionFunctionDefinitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_partitionFunctionDefinition +} + +func (*PartitionFunctionDefinitionContext) IsPartitionFunctionDefinitionContext() {} + +func NewPartitionFunctionDefinitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PartitionFunctionDefinitionContext { + var p = new(PartitionFunctionDefinitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_partitionFunctionDefinition + + return p +} + +func (s *PartitionFunctionDefinitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *PartitionFunctionDefinitionContext) CopyAll(ctx *PartitionFunctionDefinitionContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *PartitionFunctionDefinitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PartitionFunctionDefinitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type PartitionFunctionKeyContext struct { + PartitionFunctionDefinitionContext + algType antlr.Token +} + +func NewPartitionFunctionKeyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PartitionFunctionKeyContext { + var p = new(PartitionFunctionKeyContext) + + InitEmptyPartitionFunctionDefinitionContext(&p.PartitionFunctionDefinitionContext) + p.parser = parser + p.CopyAll(ctx.(*PartitionFunctionDefinitionContext)) + + return p +} + +func (s *PartitionFunctionKeyContext) GetAlgType() antlr.Token { return s.algType } + +func (s *PartitionFunctionKeyContext) SetAlgType(v antlr.Token) { s.algType = v } + +func (s *PartitionFunctionKeyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PartitionFunctionKeyContext) KEY() antlr.TerminalNode { + return s.GetToken(MySqlParserKEY, 0) +} + +func (s *PartitionFunctionKeyContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *PartitionFunctionKeyContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *PartitionFunctionKeyContext) LINEAR() antlr.TerminalNode { + return s.GetToken(MySqlParserLINEAR, 0) +} + +func (s *PartitionFunctionKeyContext) ALGORITHM() antlr.TerminalNode { + return s.GetToken(MySqlParserALGORITHM, 0) +} + +func (s *PartitionFunctionKeyContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *PartitionFunctionKeyContext) UidList() IUidListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidListContext) +} + +func (s *PartitionFunctionKeyContext) ONE_DECIMAL() antlr.TerminalNode { + return s.GetToken(MySqlParserONE_DECIMAL, 0) +} + +func (s *PartitionFunctionKeyContext) TWO_DECIMAL() antlr.TerminalNode { + return s.GetToken(MySqlParserTWO_DECIMAL, 0) +} + +func (s *PartitionFunctionKeyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterPartitionFunctionKey(s) + } +} + +func (s *PartitionFunctionKeyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitPartitionFunctionKey(s) + } +} + +type PartitionFunctionHashContext struct { + PartitionFunctionDefinitionContext +} + +func NewPartitionFunctionHashContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PartitionFunctionHashContext { + var p = new(PartitionFunctionHashContext) + + InitEmptyPartitionFunctionDefinitionContext(&p.PartitionFunctionDefinitionContext) + p.parser = parser + p.CopyAll(ctx.(*PartitionFunctionDefinitionContext)) + + return p +} + +func (s *PartitionFunctionHashContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PartitionFunctionHashContext) HASH() antlr.TerminalNode { + return s.GetToken(MySqlParserHASH, 0) +} + +func (s *PartitionFunctionHashContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *PartitionFunctionHashContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *PartitionFunctionHashContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *PartitionFunctionHashContext) LINEAR() antlr.TerminalNode { + return s.GetToken(MySqlParserLINEAR, 0) +} + +func (s *PartitionFunctionHashContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterPartitionFunctionHash(s) + } +} + +func (s *PartitionFunctionHashContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitPartitionFunctionHash(s) + } +} + +type PartitionFunctionListContext struct { + PartitionFunctionDefinitionContext +} + +func NewPartitionFunctionListContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PartitionFunctionListContext { + var p = new(PartitionFunctionListContext) + + InitEmptyPartitionFunctionDefinitionContext(&p.PartitionFunctionDefinitionContext) + p.parser = parser + p.CopyAll(ctx.(*PartitionFunctionDefinitionContext)) + + return p +} + +func (s *PartitionFunctionListContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PartitionFunctionListContext) LIST() antlr.TerminalNode { + return s.GetToken(MySqlParserLIST, 0) +} + +func (s *PartitionFunctionListContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *PartitionFunctionListContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *PartitionFunctionListContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *PartitionFunctionListContext) COLUMNS() antlr.TerminalNode { + return s.GetToken(MySqlParserCOLUMNS, 0) +} + +func (s *PartitionFunctionListContext) UidList() IUidListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidListContext) +} + +func (s *PartitionFunctionListContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterPartitionFunctionList(s) + } +} + +func (s *PartitionFunctionListContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitPartitionFunctionList(s) + } +} + +type PartitionFunctionRangeContext struct { + PartitionFunctionDefinitionContext +} + +func NewPartitionFunctionRangeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PartitionFunctionRangeContext { + var p = new(PartitionFunctionRangeContext) + + InitEmptyPartitionFunctionDefinitionContext(&p.PartitionFunctionDefinitionContext) + p.parser = parser + p.CopyAll(ctx.(*PartitionFunctionDefinitionContext)) + + return p +} + +func (s *PartitionFunctionRangeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PartitionFunctionRangeContext) RANGE() antlr.TerminalNode { + return s.GetToken(MySqlParserRANGE, 0) +} + +func (s *PartitionFunctionRangeContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *PartitionFunctionRangeContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *PartitionFunctionRangeContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *PartitionFunctionRangeContext) COLUMNS() antlr.TerminalNode { + return s.GetToken(MySqlParserCOLUMNS, 0) +} + +func (s *PartitionFunctionRangeContext) UidList() IUidListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidListContext) +} + +func (s *PartitionFunctionRangeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterPartitionFunctionRange(s) + } +} + +func (s *PartitionFunctionRangeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitPartitionFunctionRange(s) + } +} + +func (p *MySqlParser) PartitionFunctionDefinition() (localctx IPartitionFunctionDefinitionContext) { + localctx = NewPartitionFunctionDefinitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 114, MySqlParserRULE_partitionFunctionDefinition) + var _la int + + p.SetState(2091) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 240, p.GetParserRuleContext()) { + case 1: + localctx = NewPartitionFunctionHashContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + p.SetState(2046) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserLINEAR { + { + p.SetState(2045) + p.Match(MySqlParserLINEAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2048) + p.Match(MySqlParserHASH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2049) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2050) + p.expression(0) + } + { + p.SetState(2051) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + localctx = NewPartitionFunctionKeyContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + p.SetState(2054) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserLINEAR { + { + p.SetState(2053) + p.Match(MySqlParserLINEAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2056) + p.Match(MySqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2060) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserALGORITHM { + { + p.SetState(2057) + p.Match(MySqlParserALGORITHM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2058) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2059) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*PartitionFunctionKeyContext).algType = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserONE_DECIMAL || _la == MySqlParserTWO_DECIMAL) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*PartitionFunctionKeyContext).algType = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(2062) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2064) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-34354363873) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-2199023255553) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-5764611921080745985) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-8796126576641) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-32651097298436097) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-18014398517872129) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-137438953601) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-44473063500156929) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-129) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-12289) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&-1) != 0) || ((int64((_la-1128)) & ^0x3f) == 0 && ((int64(1)<<(_la-1128))&8627683329) != 0) { + { + p.SetState(2063) + p.UidList() + } + + } + { + p.SetState(2066) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + localctx = NewPartitionFunctionRangeContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2067) + p.Match(MySqlParserRANGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2077) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserLR_BRACKET: + { + p.SetState(2068) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2069) + p.expression(0) + } + { + p.SetState(2070) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserCOLUMNS: + { + p.SetState(2072) + p.Match(MySqlParserCOLUMNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2073) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2074) + p.UidList() + } + { + p.SetState(2075) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 4: + localctx = NewPartitionFunctionListContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(2079) + p.Match(MySqlParserLIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2089) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserLR_BRACKET: + { + p.SetState(2080) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2081) + p.expression(0) + } + { + p.SetState(2082) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserCOLUMNS: + { + p.SetState(2084) + p.Match(MySqlParserCOLUMNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2085) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2086) + p.UidList() + } + { + p.SetState(2087) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISubpartitionFunctionDefinitionContext is an interface to support dynamic dispatch. +type ISubpartitionFunctionDefinitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsSubpartitionFunctionDefinitionContext differentiates from other interfaces. + IsSubpartitionFunctionDefinitionContext() +} + +type SubpartitionFunctionDefinitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySubpartitionFunctionDefinitionContext() *SubpartitionFunctionDefinitionContext { + var p = new(SubpartitionFunctionDefinitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_subpartitionFunctionDefinition + return p +} + +func InitEmptySubpartitionFunctionDefinitionContext(p *SubpartitionFunctionDefinitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_subpartitionFunctionDefinition +} + +func (*SubpartitionFunctionDefinitionContext) IsSubpartitionFunctionDefinitionContext() {} + +func NewSubpartitionFunctionDefinitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SubpartitionFunctionDefinitionContext { + var p = new(SubpartitionFunctionDefinitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_subpartitionFunctionDefinition + + return p +} + +func (s *SubpartitionFunctionDefinitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *SubpartitionFunctionDefinitionContext) CopyAll(ctx *SubpartitionFunctionDefinitionContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *SubpartitionFunctionDefinitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SubpartitionFunctionDefinitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type SubPartitionFunctionHashContext struct { + SubpartitionFunctionDefinitionContext +} + +func NewSubPartitionFunctionHashContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SubPartitionFunctionHashContext { + var p = new(SubPartitionFunctionHashContext) + + InitEmptySubpartitionFunctionDefinitionContext(&p.SubpartitionFunctionDefinitionContext) + p.parser = parser + p.CopyAll(ctx.(*SubpartitionFunctionDefinitionContext)) + + return p +} + +func (s *SubPartitionFunctionHashContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SubPartitionFunctionHashContext) HASH() antlr.TerminalNode { + return s.GetToken(MySqlParserHASH, 0) +} + +func (s *SubPartitionFunctionHashContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *SubPartitionFunctionHashContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *SubPartitionFunctionHashContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *SubPartitionFunctionHashContext) LINEAR() antlr.TerminalNode { + return s.GetToken(MySqlParserLINEAR, 0) +} + +func (s *SubPartitionFunctionHashContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSubPartitionFunctionHash(s) + } +} + +func (s *SubPartitionFunctionHashContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSubPartitionFunctionHash(s) + } +} + +type SubPartitionFunctionKeyContext struct { + SubpartitionFunctionDefinitionContext + algType antlr.Token +} + +func NewSubPartitionFunctionKeyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SubPartitionFunctionKeyContext { + var p = new(SubPartitionFunctionKeyContext) + + InitEmptySubpartitionFunctionDefinitionContext(&p.SubpartitionFunctionDefinitionContext) + p.parser = parser + p.CopyAll(ctx.(*SubpartitionFunctionDefinitionContext)) + + return p +} + +func (s *SubPartitionFunctionKeyContext) GetAlgType() antlr.Token { return s.algType } + +func (s *SubPartitionFunctionKeyContext) SetAlgType(v antlr.Token) { s.algType = v } + +func (s *SubPartitionFunctionKeyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SubPartitionFunctionKeyContext) KEY() antlr.TerminalNode { + return s.GetToken(MySqlParserKEY, 0) +} + +func (s *SubPartitionFunctionKeyContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *SubPartitionFunctionKeyContext) UidList() IUidListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidListContext) +} + +func (s *SubPartitionFunctionKeyContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *SubPartitionFunctionKeyContext) LINEAR() antlr.TerminalNode { + return s.GetToken(MySqlParserLINEAR, 0) +} + +func (s *SubPartitionFunctionKeyContext) ALGORITHM() antlr.TerminalNode { + return s.GetToken(MySqlParserALGORITHM, 0) +} + +func (s *SubPartitionFunctionKeyContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *SubPartitionFunctionKeyContext) ONE_DECIMAL() antlr.TerminalNode { + return s.GetToken(MySqlParserONE_DECIMAL, 0) +} + +func (s *SubPartitionFunctionKeyContext) TWO_DECIMAL() antlr.TerminalNode { + return s.GetToken(MySqlParserTWO_DECIMAL, 0) +} + +func (s *SubPartitionFunctionKeyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSubPartitionFunctionKey(s) + } +} + +func (s *SubPartitionFunctionKeyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSubPartitionFunctionKey(s) + } +} + +func (p *MySqlParser) SubpartitionFunctionDefinition() (localctx ISubpartitionFunctionDefinitionContext) { + localctx = NewSubpartitionFunctionDefinitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 116, MySqlParserRULE_subpartitionFunctionDefinition) + var _la int + + p.SetState(2114) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 244, p.GetParserRuleContext()) { + case 1: + localctx = NewSubPartitionFunctionHashContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + p.SetState(2094) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserLINEAR { + { + p.SetState(2093) + p.Match(MySqlParserLINEAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2096) + p.Match(MySqlParserHASH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2097) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2098) + p.expression(0) + } + { + p.SetState(2099) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + localctx = NewSubPartitionFunctionKeyContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + p.SetState(2102) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserLINEAR { + { + p.SetState(2101) + p.Match(MySqlParserLINEAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2104) + p.Match(MySqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2108) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserALGORITHM { + { + p.SetState(2105) + p.Match(MySqlParserALGORITHM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2106) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2107) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*SubPartitionFunctionKeyContext).algType = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserONE_DECIMAL || _la == MySqlParserTWO_DECIMAL) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*SubPartitionFunctionKeyContext).algType = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(2110) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2111) + p.UidList() + } + { + p.SetState(2112) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPartitionDefinitionContext is an interface to support dynamic dispatch. +type IPartitionDefinitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsPartitionDefinitionContext differentiates from other interfaces. + IsPartitionDefinitionContext() +} + +type PartitionDefinitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPartitionDefinitionContext() *PartitionDefinitionContext { + var p = new(PartitionDefinitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_partitionDefinition + return p +} + +func InitEmptyPartitionDefinitionContext(p *PartitionDefinitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_partitionDefinition +} + +func (*PartitionDefinitionContext) IsPartitionDefinitionContext() {} + +func NewPartitionDefinitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PartitionDefinitionContext { + var p = new(PartitionDefinitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_partitionDefinition + + return p +} + +func (s *PartitionDefinitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *PartitionDefinitionContext) CopyAll(ctx *PartitionDefinitionContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *PartitionDefinitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PartitionDefinitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type PartitionComparisonContext struct { + PartitionDefinitionContext +} + +func NewPartitionComparisonContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PartitionComparisonContext { + var p = new(PartitionComparisonContext) + + InitEmptyPartitionDefinitionContext(&p.PartitionDefinitionContext) + p.parser = parser + p.CopyAll(ctx.(*PartitionDefinitionContext)) + + return p +} + +func (s *PartitionComparisonContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PartitionComparisonContext) PARTITION() antlr.TerminalNode { + return s.GetToken(MySqlParserPARTITION, 0) +} + +func (s *PartitionComparisonContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *PartitionComparisonContext) VALUES() antlr.TerminalNode { + return s.GetToken(MySqlParserVALUES, 0) +} + +func (s *PartitionComparisonContext) LESS() antlr.TerminalNode { + return s.GetToken(MySqlParserLESS, 0) +} + +func (s *PartitionComparisonContext) THAN() antlr.TerminalNode { + return s.GetToken(MySqlParserTHAN, 0) +} + +func (s *PartitionComparisonContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(MySqlParserLR_BRACKET) +} + +func (s *PartitionComparisonContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, i) +} + +func (s *PartitionComparisonContext) AllPartitionDefinerAtom() []IPartitionDefinerAtomContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPartitionDefinerAtomContext); ok { + len++ + } + } + + tst := make([]IPartitionDefinerAtomContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPartitionDefinerAtomContext); ok { + tst[i] = t.(IPartitionDefinerAtomContext) + i++ + } + } + + return tst +} + +func (s *PartitionComparisonContext) PartitionDefinerAtom(i int) IPartitionDefinerAtomContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionDefinerAtomContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPartitionDefinerAtomContext) +} + +func (s *PartitionComparisonContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(MySqlParserRR_BRACKET) +} + +func (s *PartitionComparisonContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, i) +} + +func (s *PartitionComparisonContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *PartitionComparisonContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *PartitionComparisonContext) AllPartitionOption() []IPartitionOptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPartitionOptionContext); ok { + len++ + } + } + + tst := make([]IPartitionOptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPartitionOptionContext); ok { + tst[i] = t.(IPartitionOptionContext) + i++ + } + } + + return tst +} + +func (s *PartitionComparisonContext) PartitionOption(i int) IPartitionOptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionOptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPartitionOptionContext) +} + +func (s *PartitionComparisonContext) AllSubpartitionDefinition() []ISubpartitionDefinitionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISubpartitionDefinitionContext); ok { + len++ + } + } + + tst := make([]ISubpartitionDefinitionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISubpartitionDefinitionContext); ok { + tst[i] = t.(ISubpartitionDefinitionContext) + i++ + } + } + + return tst +} + +func (s *PartitionComparisonContext) SubpartitionDefinition(i int) ISubpartitionDefinitionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartitionDefinitionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISubpartitionDefinitionContext) +} + +func (s *PartitionComparisonContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterPartitionComparison(s) + } +} + +func (s *PartitionComparisonContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitPartitionComparison(s) + } +} + +type PartitionListAtomContext struct { + PartitionDefinitionContext +} + +func NewPartitionListAtomContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PartitionListAtomContext { + var p = new(PartitionListAtomContext) + + InitEmptyPartitionDefinitionContext(&p.PartitionDefinitionContext) + p.parser = parser + p.CopyAll(ctx.(*PartitionDefinitionContext)) + + return p +} + +func (s *PartitionListAtomContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PartitionListAtomContext) PARTITION() antlr.TerminalNode { + return s.GetToken(MySqlParserPARTITION, 0) +} + +func (s *PartitionListAtomContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *PartitionListAtomContext) VALUES() antlr.TerminalNode { + return s.GetToken(MySqlParserVALUES, 0) +} + +func (s *PartitionListAtomContext) IN() antlr.TerminalNode { + return s.GetToken(MySqlParserIN, 0) +} + +func (s *PartitionListAtomContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(MySqlParserLR_BRACKET) +} + +func (s *PartitionListAtomContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, i) +} + +func (s *PartitionListAtomContext) AllPartitionDefinerAtom() []IPartitionDefinerAtomContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPartitionDefinerAtomContext); ok { + len++ + } + } + + tst := make([]IPartitionDefinerAtomContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPartitionDefinerAtomContext); ok { + tst[i] = t.(IPartitionDefinerAtomContext) + i++ + } + } + + return tst +} + +func (s *PartitionListAtomContext) PartitionDefinerAtom(i int) IPartitionDefinerAtomContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionDefinerAtomContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPartitionDefinerAtomContext) +} + +func (s *PartitionListAtomContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(MySqlParserRR_BRACKET) +} + +func (s *PartitionListAtomContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, i) +} + +func (s *PartitionListAtomContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *PartitionListAtomContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *PartitionListAtomContext) AllPartitionOption() []IPartitionOptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPartitionOptionContext); ok { + len++ + } + } + + tst := make([]IPartitionOptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPartitionOptionContext); ok { + tst[i] = t.(IPartitionOptionContext) + i++ + } + } + + return tst +} + +func (s *PartitionListAtomContext) PartitionOption(i int) IPartitionOptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionOptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPartitionOptionContext) +} + +func (s *PartitionListAtomContext) AllSubpartitionDefinition() []ISubpartitionDefinitionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISubpartitionDefinitionContext); ok { + len++ + } + } + + tst := make([]ISubpartitionDefinitionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISubpartitionDefinitionContext); ok { + tst[i] = t.(ISubpartitionDefinitionContext) + i++ + } + } + + return tst +} + +func (s *PartitionListAtomContext) SubpartitionDefinition(i int) ISubpartitionDefinitionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartitionDefinitionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISubpartitionDefinitionContext) +} + +func (s *PartitionListAtomContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterPartitionListAtom(s) + } +} + +func (s *PartitionListAtomContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitPartitionListAtom(s) + } +} + +type PartitionListVectorContext struct { + PartitionDefinitionContext +} + +func NewPartitionListVectorContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PartitionListVectorContext { + var p = new(PartitionListVectorContext) + + InitEmptyPartitionDefinitionContext(&p.PartitionDefinitionContext) + p.parser = parser + p.CopyAll(ctx.(*PartitionDefinitionContext)) + + return p +} + +func (s *PartitionListVectorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PartitionListVectorContext) PARTITION() antlr.TerminalNode { + return s.GetToken(MySqlParserPARTITION, 0) +} + +func (s *PartitionListVectorContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *PartitionListVectorContext) VALUES() antlr.TerminalNode { + return s.GetToken(MySqlParserVALUES, 0) +} + +func (s *PartitionListVectorContext) IN() antlr.TerminalNode { + return s.GetToken(MySqlParserIN, 0) +} + +func (s *PartitionListVectorContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(MySqlParserLR_BRACKET) +} + +func (s *PartitionListVectorContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, i) +} + +func (s *PartitionListVectorContext) AllPartitionDefinerVector() []IPartitionDefinerVectorContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPartitionDefinerVectorContext); ok { + len++ + } + } + + tst := make([]IPartitionDefinerVectorContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPartitionDefinerVectorContext); ok { + tst[i] = t.(IPartitionDefinerVectorContext) + i++ + } + } + + return tst +} + +func (s *PartitionListVectorContext) PartitionDefinerVector(i int) IPartitionDefinerVectorContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionDefinerVectorContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPartitionDefinerVectorContext) +} + +func (s *PartitionListVectorContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(MySqlParserRR_BRACKET) +} + +func (s *PartitionListVectorContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, i) +} + +func (s *PartitionListVectorContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *PartitionListVectorContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *PartitionListVectorContext) AllPartitionOption() []IPartitionOptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPartitionOptionContext); ok { + len++ + } + } + + tst := make([]IPartitionOptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPartitionOptionContext); ok { + tst[i] = t.(IPartitionOptionContext) + i++ + } + } + + return tst +} + +func (s *PartitionListVectorContext) PartitionOption(i int) IPartitionOptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionOptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPartitionOptionContext) +} + +func (s *PartitionListVectorContext) AllSubpartitionDefinition() []ISubpartitionDefinitionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISubpartitionDefinitionContext); ok { + len++ + } + } + + tst := make([]ISubpartitionDefinitionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISubpartitionDefinitionContext); ok { + tst[i] = t.(ISubpartitionDefinitionContext) + i++ + } + } + + return tst +} + +func (s *PartitionListVectorContext) SubpartitionDefinition(i int) ISubpartitionDefinitionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartitionDefinitionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISubpartitionDefinitionContext) +} + +func (s *PartitionListVectorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterPartitionListVector(s) + } +} + +func (s *PartitionListVectorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitPartitionListVector(s) + } +} + +type PartitionSimpleContext struct { + PartitionDefinitionContext +} + +func NewPartitionSimpleContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PartitionSimpleContext { + var p = new(PartitionSimpleContext) + + InitEmptyPartitionDefinitionContext(&p.PartitionDefinitionContext) + p.parser = parser + p.CopyAll(ctx.(*PartitionDefinitionContext)) + + return p +} + +func (s *PartitionSimpleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PartitionSimpleContext) PARTITION() antlr.TerminalNode { + return s.GetToken(MySqlParserPARTITION, 0) +} + +func (s *PartitionSimpleContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *PartitionSimpleContext) AllPartitionOption() []IPartitionOptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPartitionOptionContext); ok { + len++ + } + } + + tst := make([]IPartitionOptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPartitionOptionContext); ok { + tst[i] = t.(IPartitionOptionContext) + i++ + } + } + + return tst +} + +func (s *PartitionSimpleContext) PartitionOption(i int) IPartitionOptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionOptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPartitionOptionContext) +} + +func (s *PartitionSimpleContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *PartitionSimpleContext) AllSubpartitionDefinition() []ISubpartitionDefinitionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISubpartitionDefinitionContext); ok { + len++ + } + } + + tst := make([]ISubpartitionDefinitionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISubpartitionDefinitionContext); ok { + tst[i] = t.(ISubpartitionDefinitionContext) + i++ + } + } + + return tst +} + +func (s *PartitionSimpleContext) SubpartitionDefinition(i int) ISubpartitionDefinitionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartitionDefinitionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISubpartitionDefinitionContext) +} + +func (s *PartitionSimpleContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *PartitionSimpleContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *PartitionSimpleContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *PartitionSimpleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterPartitionSimple(s) + } +} + +func (s *PartitionSimpleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitPartitionSimple(s) + } +} + +func (p *MySqlParser) PartitionDefinition() (localctx IPartitionDefinitionContext) { + localctx = NewPartitionDefinitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 118, MySqlParserRULE_partitionDefinition) + var _la int + + p.SetState(2262) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 263, p.GetParserRuleContext()) { + case 1: + localctx = NewPartitionComparisonContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2116) + p.Match(MySqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2117) + p.Uid() + } + { + p.SetState(2118) + p.Match(MySqlParserVALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2119) + p.Match(MySqlParserLESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2120) + p.Match(MySqlParserTHAN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2121) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2122) + p.PartitionDefinerAtom() + } + p.SetState(2127) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(2123) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2124) + p.PartitionDefinerAtom() + } + + p.SetState(2129) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2130) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2134) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserDEFAULT || _la == MySqlParserINDEX || ((int64((_la-369)) & ^0x3f) == 0 && ((int64(1)<<(_la-369))&2199024304129) != 0) || ((int64((_la-501)) & ^0x3f) == 0 && ((int64(1)<<(_la-501))&268436481) != 0) || _la == MySqlParserSTORAGE || _la == MySqlParserTABLESPACE { + { + p.SetState(2131) + p.PartitionOption() + } + + p.SetState(2136) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(2148) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserLR_BRACKET { + { + p.SetState(2137) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2138) + p.SubpartitionDefinition() + } + p.SetState(2143) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(2139) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2140) + p.SubpartitionDefinition() + } + + p.SetState(2145) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2146) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 2: + localctx = NewPartitionComparisonContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2150) + p.Match(MySqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2151) + p.Uid() + } + { + p.SetState(2152) + p.Match(MySqlParserVALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2153) + p.Match(MySqlParserLESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2154) + p.Match(MySqlParserTHAN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2155) + p.PartitionDefinerAtom() + } + p.SetState(2159) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserDEFAULT || _la == MySqlParserINDEX || ((int64((_la-369)) & ^0x3f) == 0 && ((int64(1)<<(_la-369))&2199024304129) != 0) || ((int64((_la-501)) & ^0x3f) == 0 && ((int64(1)<<(_la-501))&268436481) != 0) || _la == MySqlParserSTORAGE || _la == MySqlParserTABLESPACE { + { + p.SetState(2156) + p.PartitionOption() + } + + p.SetState(2161) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(2173) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserLR_BRACKET { + { + p.SetState(2162) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2163) + p.SubpartitionDefinition() + } + p.SetState(2168) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(2164) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2165) + p.SubpartitionDefinition() + } + + p.SetState(2170) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2171) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 3: + localctx = NewPartitionListAtomContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2175) + p.Match(MySqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2176) + p.Uid() + } + { + p.SetState(2177) + p.Match(MySqlParserVALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2178) + p.Match(MySqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2179) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2180) + p.PartitionDefinerAtom() + } + p.SetState(2185) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(2181) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2182) + p.PartitionDefinerAtom() + } + + p.SetState(2187) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2188) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2192) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserDEFAULT || _la == MySqlParserINDEX || ((int64((_la-369)) & ^0x3f) == 0 && ((int64(1)<<(_la-369))&2199024304129) != 0) || ((int64((_la-501)) & ^0x3f) == 0 && ((int64(1)<<(_la-501))&268436481) != 0) || _la == MySqlParserSTORAGE || _la == MySqlParserTABLESPACE { + { + p.SetState(2189) + p.PartitionOption() + } + + p.SetState(2194) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(2206) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserLR_BRACKET { + { + p.SetState(2195) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2196) + p.SubpartitionDefinition() + } + p.SetState(2201) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(2197) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2198) + p.SubpartitionDefinition() + } + + p.SetState(2203) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2204) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 4: + localctx = NewPartitionListVectorContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(2208) + p.Match(MySqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2209) + p.Uid() + } + { + p.SetState(2210) + p.Match(MySqlParserVALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2211) + p.Match(MySqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2212) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2213) + p.PartitionDefinerVector() + } + p.SetState(2218) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(2214) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2215) + p.PartitionDefinerVector() + } + + p.SetState(2220) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2221) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2225) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserDEFAULT || _la == MySqlParserINDEX || ((int64((_la-369)) & ^0x3f) == 0 && ((int64(1)<<(_la-369))&2199024304129) != 0) || ((int64((_la-501)) & ^0x3f) == 0 && ((int64(1)<<(_la-501))&268436481) != 0) || _la == MySqlParserSTORAGE || _la == MySqlParserTABLESPACE { + { + p.SetState(2222) + p.PartitionOption() + } + + p.SetState(2227) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(2239) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserLR_BRACKET { + { + p.SetState(2228) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2229) + p.SubpartitionDefinition() + } + p.SetState(2234) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(2230) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2231) + p.SubpartitionDefinition() + } + + p.SetState(2236) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2237) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 5: + localctx = NewPartitionSimpleContext(p, localctx) + p.EnterOuterAlt(localctx, 5) + { + p.SetState(2241) + p.Match(MySqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2242) + p.Uid() + } + p.SetState(2246) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserDEFAULT || _la == MySqlParserINDEX || ((int64((_la-369)) & ^0x3f) == 0 && ((int64(1)<<(_la-369))&2199024304129) != 0) || ((int64((_la-501)) & ^0x3f) == 0 && ((int64(1)<<(_la-501))&268436481) != 0) || _la == MySqlParserSTORAGE || _la == MySqlParserTABLESPACE { + { + p.SetState(2243) + p.PartitionOption() + } + + p.SetState(2248) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(2260) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserLR_BRACKET { + { + p.SetState(2249) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2250) + p.SubpartitionDefinition() + } + p.SetState(2255) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(2251) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2252) + p.SubpartitionDefinition() + } + + p.SetState(2257) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2258) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPartitionDefinerAtomContext is an interface to support dynamic dispatch. +type IPartitionDefinerAtomContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Constant() IConstantContext + Expression() IExpressionContext + MAXVALUE() antlr.TerminalNode + + // IsPartitionDefinerAtomContext differentiates from other interfaces. + IsPartitionDefinerAtomContext() +} + +type PartitionDefinerAtomContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPartitionDefinerAtomContext() *PartitionDefinerAtomContext { + var p = new(PartitionDefinerAtomContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_partitionDefinerAtom + return p +} + +func InitEmptyPartitionDefinerAtomContext(p *PartitionDefinerAtomContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_partitionDefinerAtom +} + +func (*PartitionDefinerAtomContext) IsPartitionDefinerAtomContext() {} + +func NewPartitionDefinerAtomContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PartitionDefinerAtomContext { + var p = new(PartitionDefinerAtomContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_partitionDefinerAtom + + return p +} + +func (s *PartitionDefinerAtomContext) GetParser() antlr.Parser { return s.parser } + +func (s *PartitionDefinerAtomContext) Constant() IConstantContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstantContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstantContext) +} + +func (s *PartitionDefinerAtomContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *PartitionDefinerAtomContext) MAXVALUE() antlr.TerminalNode { + return s.GetToken(MySqlParserMAXVALUE, 0) +} + +func (s *PartitionDefinerAtomContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PartitionDefinerAtomContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PartitionDefinerAtomContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterPartitionDefinerAtom(s) + } +} + +func (s *PartitionDefinerAtomContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitPartitionDefinerAtom(s) + } +} + +func (p *MySqlParser) PartitionDefinerAtom() (localctx IPartitionDefinerAtomContext) { + localctx = NewPartitionDefinerAtomContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 120, MySqlParserRULE_partitionDefinerAtom) + p.SetState(2267) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 264, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2264) + p.Constant() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2265) + p.expression(0) + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2266) + p.Match(MySqlParserMAXVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPartitionDefinerVectorContext is an interface to support dynamic dispatch. +type IPartitionDefinerVectorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + AllPartitionDefinerAtom() []IPartitionDefinerAtomContext + PartitionDefinerAtom(i int) IPartitionDefinerAtomContext + RR_BRACKET() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsPartitionDefinerVectorContext differentiates from other interfaces. + IsPartitionDefinerVectorContext() +} + +type PartitionDefinerVectorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPartitionDefinerVectorContext() *PartitionDefinerVectorContext { + var p = new(PartitionDefinerVectorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_partitionDefinerVector + return p +} + +func InitEmptyPartitionDefinerVectorContext(p *PartitionDefinerVectorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_partitionDefinerVector +} + +func (*PartitionDefinerVectorContext) IsPartitionDefinerVectorContext() {} + +func NewPartitionDefinerVectorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PartitionDefinerVectorContext { + var p = new(PartitionDefinerVectorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_partitionDefinerVector + + return p +} + +func (s *PartitionDefinerVectorContext) GetParser() antlr.Parser { return s.parser } + +func (s *PartitionDefinerVectorContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *PartitionDefinerVectorContext) AllPartitionDefinerAtom() []IPartitionDefinerAtomContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPartitionDefinerAtomContext); ok { + len++ + } + } + + tst := make([]IPartitionDefinerAtomContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPartitionDefinerAtomContext); ok { + tst[i] = t.(IPartitionDefinerAtomContext) + i++ + } + } + + return tst +} + +func (s *PartitionDefinerVectorContext) PartitionDefinerAtom(i int) IPartitionDefinerAtomContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionDefinerAtomContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPartitionDefinerAtomContext) +} + +func (s *PartitionDefinerVectorContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *PartitionDefinerVectorContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *PartitionDefinerVectorContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *PartitionDefinerVectorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PartitionDefinerVectorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PartitionDefinerVectorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterPartitionDefinerVector(s) + } +} + +func (s *PartitionDefinerVectorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitPartitionDefinerVector(s) + } +} + +func (p *MySqlParser) PartitionDefinerVector() (localctx IPartitionDefinerVectorContext) { + localctx = NewPartitionDefinerVectorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 122, MySqlParserRULE_partitionDefinerVector) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2269) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2270) + p.PartitionDefinerAtom() + } + p.SetState(2273) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == MySqlParserCOMMA { + { + p.SetState(2271) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2272) + p.PartitionDefinerAtom() + } + + p.SetState(2275) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2277) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISubpartitionDefinitionContext is an interface to support dynamic dispatch. +type ISubpartitionDefinitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SUBPARTITION() antlr.TerminalNode + Uid() IUidContext + AllPartitionOption() []IPartitionOptionContext + PartitionOption(i int) IPartitionOptionContext + + // IsSubpartitionDefinitionContext differentiates from other interfaces. + IsSubpartitionDefinitionContext() +} + +type SubpartitionDefinitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySubpartitionDefinitionContext() *SubpartitionDefinitionContext { + var p = new(SubpartitionDefinitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_subpartitionDefinition + return p +} + +func InitEmptySubpartitionDefinitionContext(p *SubpartitionDefinitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_subpartitionDefinition +} + +func (*SubpartitionDefinitionContext) IsSubpartitionDefinitionContext() {} + +func NewSubpartitionDefinitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SubpartitionDefinitionContext { + var p = new(SubpartitionDefinitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_subpartitionDefinition + + return p +} + +func (s *SubpartitionDefinitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *SubpartitionDefinitionContext) SUBPARTITION() antlr.TerminalNode { + return s.GetToken(MySqlParserSUBPARTITION, 0) +} + +func (s *SubpartitionDefinitionContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *SubpartitionDefinitionContext) AllPartitionOption() []IPartitionOptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPartitionOptionContext); ok { + len++ + } + } + + tst := make([]IPartitionOptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPartitionOptionContext); ok { + tst[i] = t.(IPartitionOptionContext) + i++ + } + } + + return tst +} + +func (s *SubpartitionDefinitionContext) PartitionOption(i int) IPartitionOptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionOptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPartitionOptionContext) +} + +func (s *SubpartitionDefinitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SubpartitionDefinitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SubpartitionDefinitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSubpartitionDefinition(s) + } +} + +func (s *SubpartitionDefinitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSubpartitionDefinition(s) + } +} + +func (p *MySqlParser) SubpartitionDefinition() (localctx ISubpartitionDefinitionContext) { + localctx = NewSubpartitionDefinitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 124, MySqlParserRULE_subpartitionDefinition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2279) + p.Match(MySqlParserSUBPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2280) + p.Uid() + } + p.SetState(2284) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserDEFAULT || _la == MySqlParserINDEX || ((int64((_la-369)) & ^0x3f) == 0 && ((int64(1)<<(_la-369))&2199024304129) != 0) || ((int64((_la-501)) & ^0x3f) == 0 && ((int64(1)<<(_la-501))&268436481) != 0) || _la == MySqlParserSTORAGE || _la == MySqlParserTABLESPACE { + { + p.SetState(2281) + p.PartitionOption() + } + + p.SetState(2286) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPartitionOptionContext is an interface to support dynamic dispatch. +type IPartitionOptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsPartitionOptionContext differentiates from other interfaces. + IsPartitionOptionContext() +} + +type PartitionOptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPartitionOptionContext() *PartitionOptionContext { + var p = new(PartitionOptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_partitionOption + return p +} + +func InitEmptyPartitionOptionContext(p *PartitionOptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_partitionOption +} + +func (*PartitionOptionContext) IsPartitionOptionContext() {} + +func NewPartitionOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PartitionOptionContext { + var p = new(PartitionOptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_partitionOption + + return p +} + +func (s *PartitionOptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *PartitionOptionContext) CopyAll(ctx *PartitionOptionContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *PartitionOptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PartitionOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type PartitionOptionCommentContext struct { + PartitionOptionContext + comment antlr.Token +} + +func NewPartitionOptionCommentContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PartitionOptionCommentContext { + var p = new(PartitionOptionCommentContext) + + InitEmptyPartitionOptionContext(&p.PartitionOptionContext) + p.parser = parser + p.CopyAll(ctx.(*PartitionOptionContext)) + + return p +} + +func (s *PartitionOptionCommentContext) GetComment() antlr.Token { return s.comment } + +func (s *PartitionOptionCommentContext) SetComment(v antlr.Token) { s.comment = v } + +func (s *PartitionOptionCommentContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PartitionOptionCommentContext) COMMENT() antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMENT, 0) +} + +func (s *PartitionOptionCommentContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *PartitionOptionCommentContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *PartitionOptionCommentContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterPartitionOptionComment(s) + } +} + +func (s *PartitionOptionCommentContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitPartitionOptionComment(s) + } +} + +type PartitionOptionNodeGroupContext struct { + PartitionOptionContext + nodegroup IUidContext +} + +func NewPartitionOptionNodeGroupContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PartitionOptionNodeGroupContext { + var p = new(PartitionOptionNodeGroupContext) + + InitEmptyPartitionOptionContext(&p.PartitionOptionContext) + p.parser = parser + p.CopyAll(ctx.(*PartitionOptionContext)) + + return p +} + +func (s *PartitionOptionNodeGroupContext) GetNodegroup() IUidContext { return s.nodegroup } + +func (s *PartitionOptionNodeGroupContext) SetNodegroup(v IUidContext) { s.nodegroup = v } + +func (s *PartitionOptionNodeGroupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PartitionOptionNodeGroupContext) NODEGROUP() antlr.TerminalNode { + return s.GetToken(MySqlParserNODEGROUP, 0) +} + +func (s *PartitionOptionNodeGroupContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *PartitionOptionNodeGroupContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *PartitionOptionNodeGroupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterPartitionOptionNodeGroup(s) + } +} + +func (s *PartitionOptionNodeGroupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitPartitionOptionNodeGroup(s) + } +} + +type PartitionOptionIndexDirectoryContext struct { + PartitionOptionContext + indexDirectory antlr.Token +} + +func NewPartitionOptionIndexDirectoryContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PartitionOptionIndexDirectoryContext { + var p = new(PartitionOptionIndexDirectoryContext) + + InitEmptyPartitionOptionContext(&p.PartitionOptionContext) + p.parser = parser + p.CopyAll(ctx.(*PartitionOptionContext)) + + return p +} + +func (s *PartitionOptionIndexDirectoryContext) GetIndexDirectory() antlr.Token { + return s.indexDirectory +} + +func (s *PartitionOptionIndexDirectoryContext) SetIndexDirectory(v antlr.Token) { s.indexDirectory = v } + +func (s *PartitionOptionIndexDirectoryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PartitionOptionIndexDirectoryContext) INDEX() antlr.TerminalNode { + return s.GetToken(MySqlParserINDEX, 0) +} + +func (s *PartitionOptionIndexDirectoryContext) DIRECTORY() antlr.TerminalNode { + return s.GetToken(MySqlParserDIRECTORY, 0) +} + +func (s *PartitionOptionIndexDirectoryContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *PartitionOptionIndexDirectoryContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *PartitionOptionIndexDirectoryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterPartitionOptionIndexDirectory(s) + } +} + +func (s *PartitionOptionIndexDirectoryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitPartitionOptionIndexDirectory(s) + } +} + +type PartitionOptionMaxRowsContext struct { + PartitionOptionContext + maxRows IDecimalLiteralContext +} + +func NewPartitionOptionMaxRowsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PartitionOptionMaxRowsContext { + var p = new(PartitionOptionMaxRowsContext) + + InitEmptyPartitionOptionContext(&p.PartitionOptionContext) + p.parser = parser + p.CopyAll(ctx.(*PartitionOptionContext)) + + return p +} + +func (s *PartitionOptionMaxRowsContext) GetMaxRows() IDecimalLiteralContext { return s.maxRows } + +func (s *PartitionOptionMaxRowsContext) SetMaxRows(v IDecimalLiteralContext) { s.maxRows = v } + +func (s *PartitionOptionMaxRowsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PartitionOptionMaxRowsContext) MAX_ROWS() antlr.TerminalNode { + return s.GetToken(MySqlParserMAX_ROWS, 0) +} + +func (s *PartitionOptionMaxRowsContext) DecimalLiteral() IDecimalLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *PartitionOptionMaxRowsContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *PartitionOptionMaxRowsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterPartitionOptionMaxRows(s) + } +} + +func (s *PartitionOptionMaxRowsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitPartitionOptionMaxRows(s) + } +} + +type PartitionOptionTablespaceContext struct { + PartitionOptionContext + tablespace IUidContext +} + +func NewPartitionOptionTablespaceContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PartitionOptionTablespaceContext { + var p = new(PartitionOptionTablespaceContext) + + InitEmptyPartitionOptionContext(&p.PartitionOptionContext) + p.parser = parser + p.CopyAll(ctx.(*PartitionOptionContext)) + + return p +} + +func (s *PartitionOptionTablespaceContext) GetTablespace() IUidContext { return s.tablespace } + +func (s *PartitionOptionTablespaceContext) SetTablespace(v IUidContext) { s.tablespace = v } + +func (s *PartitionOptionTablespaceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PartitionOptionTablespaceContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLESPACE, 0) +} + +func (s *PartitionOptionTablespaceContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *PartitionOptionTablespaceContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *PartitionOptionTablespaceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterPartitionOptionTablespace(s) + } +} + +func (s *PartitionOptionTablespaceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitPartitionOptionTablespace(s) + } +} + +type PartitionOptionEngineContext struct { + PartitionOptionContext +} + +func NewPartitionOptionEngineContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PartitionOptionEngineContext { + var p = new(PartitionOptionEngineContext) + + InitEmptyPartitionOptionContext(&p.PartitionOptionContext) + p.parser = parser + p.CopyAll(ctx.(*PartitionOptionContext)) + + return p +} + +func (s *PartitionOptionEngineContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PartitionOptionEngineContext) ENGINE() antlr.TerminalNode { + return s.GetToken(MySqlParserENGINE, 0) +} + +func (s *PartitionOptionEngineContext) EngineName() IEngineNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEngineNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEngineNameContext) +} + +func (s *PartitionOptionEngineContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(MySqlParserDEFAULT, 0) +} + +func (s *PartitionOptionEngineContext) STORAGE() antlr.TerminalNode { + return s.GetToken(MySqlParserSTORAGE, 0) +} + +func (s *PartitionOptionEngineContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *PartitionOptionEngineContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterPartitionOptionEngine(s) + } +} + +func (s *PartitionOptionEngineContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitPartitionOptionEngine(s) + } +} + +type PartitionOptionMinRowsContext struct { + PartitionOptionContext + minRows IDecimalLiteralContext +} + +func NewPartitionOptionMinRowsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PartitionOptionMinRowsContext { + var p = new(PartitionOptionMinRowsContext) + + InitEmptyPartitionOptionContext(&p.PartitionOptionContext) + p.parser = parser + p.CopyAll(ctx.(*PartitionOptionContext)) + + return p +} + +func (s *PartitionOptionMinRowsContext) GetMinRows() IDecimalLiteralContext { return s.minRows } + +func (s *PartitionOptionMinRowsContext) SetMinRows(v IDecimalLiteralContext) { s.minRows = v } + +func (s *PartitionOptionMinRowsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PartitionOptionMinRowsContext) MIN_ROWS() antlr.TerminalNode { + return s.GetToken(MySqlParserMIN_ROWS, 0) +} + +func (s *PartitionOptionMinRowsContext) DecimalLiteral() IDecimalLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *PartitionOptionMinRowsContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *PartitionOptionMinRowsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterPartitionOptionMinRows(s) + } +} + +func (s *PartitionOptionMinRowsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitPartitionOptionMinRows(s) + } +} + +type PartitionOptionDataDirectoryContext struct { + PartitionOptionContext + dataDirectory antlr.Token +} + +func NewPartitionOptionDataDirectoryContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PartitionOptionDataDirectoryContext { + var p = new(PartitionOptionDataDirectoryContext) + + InitEmptyPartitionOptionContext(&p.PartitionOptionContext) + p.parser = parser + p.CopyAll(ctx.(*PartitionOptionContext)) + + return p +} + +func (s *PartitionOptionDataDirectoryContext) GetDataDirectory() antlr.Token { return s.dataDirectory } + +func (s *PartitionOptionDataDirectoryContext) SetDataDirectory(v antlr.Token) { s.dataDirectory = v } + +func (s *PartitionOptionDataDirectoryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PartitionOptionDataDirectoryContext) DATA() antlr.TerminalNode { + return s.GetToken(MySqlParserDATA, 0) +} + +func (s *PartitionOptionDataDirectoryContext) DIRECTORY() antlr.TerminalNode { + return s.GetToken(MySqlParserDIRECTORY, 0) +} + +func (s *PartitionOptionDataDirectoryContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *PartitionOptionDataDirectoryContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *PartitionOptionDataDirectoryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterPartitionOptionDataDirectory(s) + } +} + +func (s *PartitionOptionDataDirectoryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitPartitionOptionDataDirectory(s) + } +} + +func (p *MySqlParser) PartitionOption() (localctx IPartitionOptionContext) { + localctx = NewPartitionOptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 126, MySqlParserRULE_partitionOption) + var _la int + + p.SetState(2335) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserDEFAULT, MySqlParserENGINE, MySqlParserSTORAGE: + localctx = NewPartitionOptionEngineContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + p.SetState(2288) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserDEFAULT { + { + p.SetState(2287) + p.Match(MySqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(2291) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserSTORAGE { + { + p.SetState(2290) + p.Match(MySqlParserSTORAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2293) + p.Match(MySqlParserENGINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2295) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(2294) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2297) + p.EngineName() + } + + case MySqlParserCOMMENT: + localctx = NewPartitionOptionCommentContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2298) + p.Match(MySqlParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2300) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(2299) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2302) + + var _m = p.Match(MySqlParserSTRING_LITERAL) + + localctx.(*PartitionOptionCommentContext).comment = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserDATA: + localctx = NewPartitionOptionDataDirectoryContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2303) + p.Match(MySqlParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2304) + p.Match(MySqlParserDIRECTORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2306) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(2305) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2308) + + var _m = p.Match(MySqlParserSTRING_LITERAL) + + localctx.(*PartitionOptionDataDirectoryContext).dataDirectory = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserINDEX: + localctx = NewPartitionOptionIndexDirectoryContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(2309) + p.Match(MySqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2310) + p.Match(MySqlParserDIRECTORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2312) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(2311) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2314) + + var _m = p.Match(MySqlParserSTRING_LITERAL) + + localctx.(*PartitionOptionIndexDirectoryContext).indexDirectory = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserMAX_ROWS: + localctx = NewPartitionOptionMaxRowsContext(p, localctx) + p.EnterOuterAlt(localctx, 5) + { + p.SetState(2315) + p.Match(MySqlParserMAX_ROWS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2317) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(2316) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2319) + + var _x = p.DecimalLiteral() + + localctx.(*PartitionOptionMaxRowsContext).maxRows = _x + } + + case MySqlParserMIN_ROWS: + localctx = NewPartitionOptionMinRowsContext(p, localctx) + p.EnterOuterAlt(localctx, 6) + { + p.SetState(2320) + p.Match(MySqlParserMIN_ROWS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2322) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(2321) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2324) + + var _x = p.DecimalLiteral() + + localctx.(*PartitionOptionMinRowsContext).minRows = _x + } + + case MySqlParserTABLESPACE: + localctx = NewPartitionOptionTablespaceContext(p, localctx) + p.EnterOuterAlt(localctx, 7) + { + p.SetState(2325) + p.Match(MySqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2327) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(2326) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2329) + + var _x = p.Uid() + + localctx.(*PartitionOptionTablespaceContext).tablespace = _x + } + + case MySqlParserNODEGROUP: + localctx = NewPartitionOptionNodeGroupContext(p, localctx) + p.EnterOuterAlt(localctx, 8) + { + p.SetState(2330) + p.Match(MySqlParserNODEGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2332) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(2331) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2334) + + var _x = p.Uid() + + localctx.(*PartitionOptionNodeGroupContext).nodegroup = _x + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterDatabaseContext is an interface to support dynamic dispatch. +type IAlterDatabaseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsAlterDatabaseContext differentiates from other interfaces. + IsAlterDatabaseContext() +} + +type AlterDatabaseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterDatabaseContext() *AlterDatabaseContext { + var p = new(AlterDatabaseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_alterDatabase + return p +} + +func InitEmptyAlterDatabaseContext(p *AlterDatabaseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_alterDatabase +} + +func (*AlterDatabaseContext) IsAlterDatabaseContext() {} + +func NewAlterDatabaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterDatabaseContext { + var p = new(AlterDatabaseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_alterDatabase + + return p +} + +func (s *AlterDatabaseContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterDatabaseContext) CopyAll(ctx *AlterDatabaseContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *AlterDatabaseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterDatabaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type AlterUpgradeNameContext struct { + AlterDatabaseContext + dbFormat antlr.Token +} + +func NewAlterUpgradeNameContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterUpgradeNameContext { + var p = new(AlterUpgradeNameContext) + + InitEmptyAlterDatabaseContext(&p.AlterDatabaseContext) + p.parser = parser + p.CopyAll(ctx.(*AlterDatabaseContext)) + + return p +} + +func (s *AlterUpgradeNameContext) GetDbFormat() antlr.Token { return s.dbFormat } + +func (s *AlterUpgradeNameContext) SetDbFormat(v antlr.Token) { s.dbFormat = v } + +func (s *AlterUpgradeNameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterUpgradeNameContext) ALTER() antlr.TerminalNode { + return s.GetToken(MySqlParserALTER, 0) +} + +func (s *AlterUpgradeNameContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *AlterUpgradeNameContext) UPGRADE() antlr.TerminalNode { + return s.GetToken(MySqlParserUPGRADE, 0) +} + +func (s *AlterUpgradeNameContext) DATA() antlr.TerminalNode { + return s.GetToken(MySqlParserDATA, 0) +} + +func (s *AlterUpgradeNameContext) DIRECTORY() antlr.TerminalNode { + return s.GetToken(MySqlParserDIRECTORY, 0) +} + +func (s *AlterUpgradeNameContext) NAME() antlr.TerminalNode { + return s.GetToken(MySqlParserNAME, 0) +} + +func (s *AlterUpgradeNameContext) DATABASE() antlr.TerminalNode { + return s.GetToken(MySqlParserDATABASE, 0) +} + +func (s *AlterUpgradeNameContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(MySqlParserSCHEMA, 0) +} + +func (s *AlterUpgradeNameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterUpgradeName(s) + } +} + +func (s *AlterUpgradeNameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterUpgradeName(s) + } +} + +type AlterSimpleDatabaseContext struct { + AlterDatabaseContext + dbFormat antlr.Token +} + +func NewAlterSimpleDatabaseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterSimpleDatabaseContext { + var p = new(AlterSimpleDatabaseContext) + + InitEmptyAlterDatabaseContext(&p.AlterDatabaseContext) + p.parser = parser + p.CopyAll(ctx.(*AlterDatabaseContext)) + + return p +} + +func (s *AlterSimpleDatabaseContext) GetDbFormat() antlr.Token { return s.dbFormat } + +func (s *AlterSimpleDatabaseContext) SetDbFormat(v antlr.Token) { s.dbFormat = v } + +func (s *AlterSimpleDatabaseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterSimpleDatabaseContext) ALTER() antlr.TerminalNode { + return s.GetToken(MySqlParserALTER, 0) +} + +func (s *AlterSimpleDatabaseContext) DATABASE() antlr.TerminalNode { + return s.GetToken(MySqlParserDATABASE, 0) +} + +func (s *AlterSimpleDatabaseContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(MySqlParserSCHEMA, 0) +} + +func (s *AlterSimpleDatabaseContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *AlterSimpleDatabaseContext) AllCreateDatabaseOption() []ICreateDatabaseOptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICreateDatabaseOptionContext); ok { + len++ + } + } + + tst := make([]ICreateDatabaseOptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICreateDatabaseOptionContext); ok { + tst[i] = t.(ICreateDatabaseOptionContext) + i++ + } + } + + return tst +} + +func (s *AlterSimpleDatabaseContext) CreateDatabaseOption(i int) ICreateDatabaseOptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateDatabaseOptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICreateDatabaseOptionContext) +} + +func (s *AlterSimpleDatabaseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterSimpleDatabase(s) + } +} + +func (s *AlterSimpleDatabaseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterSimpleDatabase(s) + } +} + +func (p *MySqlParser) AlterDatabase() (localctx IAlterDatabaseContext) { + localctx = NewAlterDatabaseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 128, MySqlParserRULE_alterDatabase) + var _la int + + p.SetState(2355) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 280, p.GetParserRuleContext()) { + case 1: + localctx = NewAlterSimpleDatabaseContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2337) + p.Match(MySqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2338) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*AlterSimpleDatabaseContext).dbFormat = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserDATABASE || _la == MySqlParserSCHEMA) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*AlterSimpleDatabaseContext).dbFormat = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(2340) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 278, p.GetParserRuleContext()) == 1 { + { + p.SetState(2339) + p.Uid() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(2343) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&4398214283264) != 0) || _la == MySqlParserREAD || _la == MySqlParserCHAR || _la == MySqlParserENCRYPTION || _la == MySqlParserCHARSET { + { + p.SetState(2342) + p.CreateDatabaseOption() + } + + p.SetState(2345) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 2: + localctx = NewAlterUpgradeNameContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2347) + p.Match(MySqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2348) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*AlterUpgradeNameContext).dbFormat = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserDATABASE || _la == MySqlParserSCHEMA) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*AlterUpgradeNameContext).dbFormat = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2349) + p.Uid() + } + { + p.SetState(2350) + p.Match(MySqlParserUPGRADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2351) + p.Match(MySqlParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2352) + p.Match(MySqlParserDIRECTORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2353) + p.Match(MySqlParserNAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterEventContext is an interface to support dynamic dispatch. +type IAlterEventContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + EVENT() antlr.TerminalNode + AllFullId() []IFullIdContext + FullId(i int) IFullIdContext + OwnerStatement() IOwnerStatementContext + AllON() []antlr.TerminalNode + ON(i int) antlr.TerminalNode + SCHEDULE() antlr.TerminalNode + ScheduleExpression() IScheduleExpressionContext + COMPLETION() antlr.TerminalNode + PRESERVE() antlr.TerminalNode + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + EnableType() IEnableTypeContext + COMMENT() antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + DO() antlr.TerminalNode + RoutineBody() IRoutineBodyContext + NOT() antlr.TerminalNode + + // IsAlterEventContext differentiates from other interfaces. + IsAlterEventContext() +} + +type AlterEventContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterEventContext() *AlterEventContext { + var p = new(AlterEventContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_alterEvent + return p +} + +func InitEmptyAlterEventContext(p *AlterEventContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_alterEvent +} + +func (*AlterEventContext) IsAlterEventContext() {} + +func NewAlterEventContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterEventContext { + var p = new(AlterEventContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_alterEvent + + return p +} + +func (s *AlterEventContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterEventContext) ALTER() antlr.TerminalNode { + return s.GetToken(MySqlParserALTER, 0) +} + +func (s *AlterEventContext) EVENT() antlr.TerminalNode { + return s.GetToken(MySqlParserEVENT, 0) +} + +func (s *AlterEventContext) AllFullId() []IFullIdContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFullIdContext); ok { + len++ + } + } + + tst := make([]IFullIdContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFullIdContext); ok { + tst[i] = t.(IFullIdContext) + i++ + } + } + + return tst +} + +func (s *AlterEventContext) FullId(i int) IFullIdContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFullIdContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFullIdContext) +} + +func (s *AlterEventContext) OwnerStatement() IOwnerStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOwnerStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOwnerStatementContext) +} + +func (s *AlterEventContext) AllON() []antlr.TerminalNode { + return s.GetTokens(MySqlParserON) +} + +func (s *AlterEventContext) ON(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserON, i) +} + +func (s *AlterEventContext) SCHEDULE() antlr.TerminalNode { + return s.GetToken(MySqlParserSCHEDULE, 0) +} + +func (s *AlterEventContext) ScheduleExpression() IScheduleExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IScheduleExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IScheduleExpressionContext) +} + +func (s *AlterEventContext) COMPLETION() antlr.TerminalNode { + return s.GetToken(MySqlParserCOMPLETION, 0) +} + +func (s *AlterEventContext) PRESERVE() antlr.TerminalNode { + return s.GetToken(MySqlParserPRESERVE, 0) +} + +func (s *AlterEventContext) RENAME() antlr.TerminalNode { + return s.GetToken(MySqlParserRENAME, 0) +} + +func (s *AlterEventContext) TO() antlr.TerminalNode { + return s.GetToken(MySqlParserTO, 0) +} + +func (s *AlterEventContext) EnableType() IEnableTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEnableTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEnableTypeContext) +} + +func (s *AlterEventContext) COMMENT() antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMENT, 0) +} + +func (s *AlterEventContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *AlterEventContext) DO() antlr.TerminalNode { + return s.GetToken(MySqlParserDO, 0) +} + +func (s *AlterEventContext) RoutineBody() IRoutineBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRoutineBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRoutineBodyContext) +} + +func (s *AlterEventContext) NOT() antlr.TerminalNode { + return s.GetToken(MySqlParserNOT, 0) +} + +func (s *AlterEventContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterEventContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterEventContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterEvent(s) + } +} + +func (s *AlterEventContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterEvent(s) + } +} + +func (p *MySqlParser) AlterEvent() (localctx IAlterEventContext) { + localctx = NewAlterEventContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 130, MySqlParserRULE_alterEvent) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2357) + p.Match(MySqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2359) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserDEFINER { + { + p.SetState(2358) + p.OwnerStatement() + } + + } + { + p.SetState(2361) + p.Match(MySqlParserEVENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2362) + p.FullId() + } + p.SetState(2366) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 282, p.GetParserRuleContext()) == 1 { + { + p.SetState(2363) + p.Match(MySqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2364) + p.Match(MySqlParserSCHEDULE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2365) + p.ScheduleExpression() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(2374) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserON { + { + p.SetState(2368) + p.Match(MySqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2369) + p.Match(MySqlParserCOMPLETION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2371) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserNOT { + { + p.SetState(2370) + p.Match(MySqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2373) + p.Match(MySqlParserPRESERVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(2379) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 285, p.GetParserRuleContext()) == 1 { + { + p.SetState(2376) + p.Match(MySqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2377) + p.Match(MySqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2378) + p.FullId() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(2382) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserDISABLE || _la == MySqlParserENABLE { + { + p.SetState(2381) + p.EnableType() + } + + } + p.SetState(2386) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserCOMMENT { + { + p.SetState(2384) + p.Match(MySqlParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2385) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(2390) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 288, p.GetParserRuleContext()) == 1 { + { + p.SetState(2388) + p.Match(MySqlParserDO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2389) + p.RoutineBody() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterFunctionContext is an interface to support dynamic dispatch. +type IAlterFunctionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + FullId() IFullIdContext + AllRoutineOption() []IRoutineOptionContext + RoutineOption(i int) IRoutineOptionContext + + // IsAlterFunctionContext differentiates from other interfaces. + IsAlterFunctionContext() +} + +type AlterFunctionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterFunctionContext() *AlterFunctionContext { + var p = new(AlterFunctionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_alterFunction + return p +} + +func InitEmptyAlterFunctionContext(p *AlterFunctionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_alterFunction +} + +func (*AlterFunctionContext) IsAlterFunctionContext() {} + +func NewAlterFunctionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterFunctionContext { + var p = new(AlterFunctionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_alterFunction + + return p +} + +func (s *AlterFunctionContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterFunctionContext) ALTER() antlr.TerminalNode { + return s.GetToken(MySqlParserALTER, 0) +} + +func (s *AlterFunctionContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(MySqlParserFUNCTION, 0) +} + +func (s *AlterFunctionContext) FullId() IFullIdContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFullIdContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFullIdContext) +} + +func (s *AlterFunctionContext) AllRoutineOption() []IRoutineOptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRoutineOptionContext); ok { + len++ + } + } + + tst := make([]IRoutineOptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRoutineOptionContext); ok { + tst[i] = t.(IRoutineOptionContext) + i++ + } + } + + return tst +} + +func (s *AlterFunctionContext) RoutineOption(i int) IRoutineOptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRoutineOptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRoutineOptionContext) +} + +func (s *AlterFunctionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterFunctionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterFunctionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterFunction(s) + } +} + +func (s *AlterFunctionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterFunction(s) + } +} + +func (p *MySqlParser) AlterFunction() (localctx IAlterFunctionContext) { + localctx = NewAlterFunctionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 132, MySqlParserRULE_alterFunction) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2392) + p.Match(MySqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2393) + p.Match(MySqlParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2394) + p.FullId() + } + p.SetState(2398) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserDETERMINISTIC || ((int64((_la-112)) & ^0x3f) == 0 && ((int64(1)<<(_la-112))&281474985099269) != 0) || _la == MySqlParserCOMMENT || _la == MySqlParserCONTAINS || _la == MySqlParserLANGUAGE || _la == MySqlParserNO { + { + p.SetState(2395) + p.RoutineOption() + } + + p.SetState(2400) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterInstanceContext is an interface to support dynamic dispatch. +type IAlterInstanceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + INSTANCE() antlr.TerminalNode + ROTATE() antlr.TerminalNode + INNODB() antlr.TerminalNode + MASTER() antlr.TerminalNode + KEY() antlr.TerminalNode + + // IsAlterInstanceContext differentiates from other interfaces. + IsAlterInstanceContext() +} + +type AlterInstanceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterInstanceContext() *AlterInstanceContext { + var p = new(AlterInstanceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_alterInstance + return p +} + +func InitEmptyAlterInstanceContext(p *AlterInstanceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_alterInstance +} + +func (*AlterInstanceContext) IsAlterInstanceContext() {} + +func NewAlterInstanceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterInstanceContext { + var p = new(AlterInstanceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_alterInstance + + return p +} + +func (s *AlterInstanceContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterInstanceContext) ALTER() antlr.TerminalNode { + return s.GetToken(MySqlParserALTER, 0) +} + +func (s *AlterInstanceContext) INSTANCE() antlr.TerminalNode { + return s.GetToken(MySqlParserINSTANCE, 0) +} + +func (s *AlterInstanceContext) ROTATE() antlr.TerminalNode { + return s.GetToken(MySqlParserROTATE, 0) +} + +func (s *AlterInstanceContext) INNODB() antlr.TerminalNode { + return s.GetToken(MySqlParserINNODB, 0) +} + +func (s *AlterInstanceContext) MASTER() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER, 0) +} + +func (s *AlterInstanceContext) KEY() antlr.TerminalNode { + return s.GetToken(MySqlParserKEY, 0) +} + +func (s *AlterInstanceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterInstanceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterInstanceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterInstance(s) + } +} + +func (s *AlterInstanceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterInstance(s) + } +} + +func (p *MySqlParser) AlterInstance() (localctx IAlterInstanceContext) { + localctx = NewAlterInstanceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 134, MySqlParserRULE_alterInstance) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2401) + p.Match(MySqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2402) + p.Match(MySqlParserINSTANCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2403) + p.Match(MySqlParserROTATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2404) + p.Match(MySqlParserINNODB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2405) + p.Match(MySqlParserMASTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2406) + p.Match(MySqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterLogfileGroupContext is an interface to support dynamic dispatch. +type IAlterLogfileGroupContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + LOGFILE() antlr.TerminalNode + GROUP() antlr.TerminalNode + Uid() IUidContext + ADD() antlr.TerminalNode + UNDOFILE() antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + ENGINE() antlr.TerminalNode + EngineName() IEngineNameContext + INITIAL_SIZE() antlr.TerminalNode + FileSizeLiteral() IFileSizeLiteralContext + WAIT() antlr.TerminalNode + AllEQUAL_SYMBOL() []antlr.TerminalNode + EQUAL_SYMBOL(i int) antlr.TerminalNode + + // IsAlterLogfileGroupContext differentiates from other interfaces. + IsAlterLogfileGroupContext() +} + +type AlterLogfileGroupContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterLogfileGroupContext() *AlterLogfileGroupContext { + var p = new(AlterLogfileGroupContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_alterLogfileGroup + return p +} + +func InitEmptyAlterLogfileGroupContext(p *AlterLogfileGroupContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_alterLogfileGroup +} + +func (*AlterLogfileGroupContext) IsAlterLogfileGroupContext() {} + +func NewAlterLogfileGroupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterLogfileGroupContext { + var p = new(AlterLogfileGroupContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_alterLogfileGroup + + return p +} + +func (s *AlterLogfileGroupContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterLogfileGroupContext) ALTER() antlr.TerminalNode { + return s.GetToken(MySqlParserALTER, 0) +} + +func (s *AlterLogfileGroupContext) LOGFILE() antlr.TerminalNode { + return s.GetToken(MySqlParserLOGFILE, 0) +} + +func (s *AlterLogfileGroupContext) GROUP() antlr.TerminalNode { + return s.GetToken(MySqlParserGROUP, 0) +} + +func (s *AlterLogfileGroupContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *AlterLogfileGroupContext) ADD() antlr.TerminalNode { + return s.GetToken(MySqlParserADD, 0) +} + +func (s *AlterLogfileGroupContext) UNDOFILE() antlr.TerminalNode { + return s.GetToken(MySqlParserUNDOFILE, 0) +} + +func (s *AlterLogfileGroupContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *AlterLogfileGroupContext) ENGINE() antlr.TerminalNode { + return s.GetToken(MySqlParserENGINE, 0) +} + +func (s *AlterLogfileGroupContext) EngineName() IEngineNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEngineNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEngineNameContext) +} + +func (s *AlterLogfileGroupContext) INITIAL_SIZE() antlr.TerminalNode { + return s.GetToken(MySqlParserINITIAL_SIZE, 0) +} + +func (s *AlterLogfileGroupContext) FileSizeLiteral() IFileSizeLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFileSizeLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFileSizeLiteralContext) +} + +func (s *AlterLogfileGroupContext) WAIT() antlr.TerminalNode { + return s.GetToken(MySqlParserWAIT, 0) +} + +func (s *AlterLogfileGroupContext) AllEQUAL_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(MySqlParserEQUAL_SYMBOL) +} + +func (s *AlterLogfileGroupContext) EQUAL_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, i) +} + +func (s *AlterLogfileGroupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterLogfileGroupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterLogfileGroupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterLogfileGroup(s) + } +} + +func (s *AlterLogfileGroupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterLogfileGroup(s) + } +} + +func (p *MySqlParser) AlterLogfileGroup() (localctx IAlterLogfileGroupContext) { + localctx = NewAlterLogfileGroupContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 136, MySqlParserRULE_alterLogfileGroup) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2408) + p.Match(MySqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2409) + p.Match(MySqlParserLOGFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2410) + p.Match(MySqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2411) + p.Uid() + } + { + p.SetState(2412) + p.Match(MySqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2413) + p.Match(MySqlParserUNDOFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2414) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2420) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserINITIAL_SIZE { + { + p.SetState(2415) + p.Match(MySqlParserINITIAL_SIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2417) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(2416) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2419) + p.FileSizeLiteral() + } + + } + p.SetState(2423) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserWAIT { + { + p.SetState(2422) + p.Match(MySqlParserWAIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2425) + p.Match(MySqlParserENGINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2427) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(2426) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2429) + p.EngineName() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterProcedureContext is an interface to support dynamic dispatch. +type IAlterProcedureContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + PROCEDURE() antlr.TerminalNode + FullId() IFullIdContext + AllRoutineOption() []IRoutineOptionContext + RoutineOption(i int) IRoutineOptionContext + + // IsAlterProcedureContext differentiates from other interfaces. + IsAlterProcedureContext() +} + +type AlterProcedureContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterProcedureContext() *AlterProcedureContext { + var p = new(AlterProcedureContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_alterProcedure + return p +} + +func InitEmptyAlterProcedureContext(p *AlterProcedureContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_alterProcedure +} + +func (*AlterProcedureContext) IsAlterProcedureContext() {} + +func NewAlterProcedureContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterProcedureContext { + var p = new(AlterProcedureContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_alterProcedure + + return p +} + +func (s *AlterProcedureContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterProcedureContext) ALTER() antlr.TerminalNode { + return s.GetToken(MySqlParserALTER, 0) +} + +func (s *AlterProcedureContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(MySqlParserPROCEDURE, 0) +} + +func (s *AlterProcedureContext) FullId() IFullIdContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFullIdContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFullIdContext) +} + +func (s *AlterProcedureContext) AllRoutineOption() []IRoutineOptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRoutineOptionContext); ok { + len++ + } + } + + tst := make([]IRoutineOptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRoutineOptionContext); ok { + tst[i] = t.(IRoutineOptionContext) + i++ + } + } + + return tst +} + +func (s *AlterProcedureContext) RoutineOption(i int) IRoutineOptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRoutineOptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRoutineOptionContext) +} + +func (s *AlterProcedureContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterProcedureContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterProcedureContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterProcedure(s) + } +} + +func (s *AlterProcedureContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterProcedure(s) + } +} + +func (p *MySqlParser) AlterProcedure() (localctx IAlterProcedureContext) { + localctx = NewAlterProcedureContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 138, MySqlParserRULE_alterProcedure) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2431) + p.Match(MySqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2432) + p.Match(MySqlParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2433) + p.FullId() + } + p.SetState(2437) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserDETERMINISTIC || ((int64((_la-112)) & ^0x3f) == 0 && ((int64(1)<<(_la-112))&281474985099269) != 0) || _la == MySqlParserCOMMENT || _la == MySqlParserCONTAINS || _la == MySqlParserLANGUAGE || _la == MySqlParserNO { + { + p.SetState(2434) + p.RoutineOption() + } + + p.SetState(2439) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterServerContext is an interface to support dynamic dispatch. +type IAlterServerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + SERVER() antlr.TerminalNode + Uid() IUidContext + OPTIONS() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + AllServerOption() []IServerOptionContext + ServerOption(i int) IServerOptionContext + RR_BRACKET() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAlterServerContext differentiates from other interfaces. + IsAlterServerContext() +} + +type AlterServerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterServerContext() *AlterServerContext { + var p = new(AlterServerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_alterServer + return p +} + +func InitEmptyAlterServerContext(p *AlterServerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_alterServer +} + +func (*AlterServerContext) IsAlterServerContext() {} + +func NewAlterServerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterServerContext { + var p = new(AlterServerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_alterServer + + return p +} + +func (s *AlterServerContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterServerContext) ALTER() antlr.TerminalNode { + return s.GetToken(MySqlParserALTER, 0) +} + +func (s *AlterServerContext) SERVER() antlr.TerminalNode { + return s.GetToken(MySqlParserSERVER, 0) +} + +func (s *AlterServerContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *AlterServerContext) OPTIONS() antlr.TerminalNode { + return s.GetToken(MySqlParserOPTIONS, 0) +} + +func (s *AlterServerContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *AlterServerContext) AllServerOption() []IServerOptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IServerOptionContext); ok { + len++ + } + } + + tst := make([]IServerOptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IServerOptionContext); ok { + tst[i] = t.(IServerOptionContext) + i++ + } + } + + return tst +} + +func (s *AlterServerContext) ServerOption(i int) IServerOptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IServerOptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IServerOptionContext) +} + +func (s *AlterServerContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *AlterServerContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *AlterServerContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *AlterServerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterServerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterServerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterServer(s) + } +} + +func (s *AlterServerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterServer(s) + } +} + +func (p *MySqlParser) AlterServer() (localctx IAlterServerContext) { + localctx = NewAlterServerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 140, MySqlParserRULE_alterServer) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2440) + p.Match(MySqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2441) + p.Match(MySqlParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2442) + p.Uid() + } + { + p.SetState(2443) + p.Match(MySqlParserOPTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2444) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2445) + p.ServerOption() + } + p.SetState(2450) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(2446) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2447) + p.ServerOption() + } + + p.SetState(2452) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2453) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterTableContext is an interface to support dynamic dispatch. +type IAlterTableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetIntimeAction returns the intimeAction token. + GetIntimeAction() antlr.Token + + // SetIntimeAction sets the intimeAction token. + SetIntimeAction(antlr.Token) + + // Getter signatures + ALTER() antlr.TerminalNode + TABLE() antlr.TerminalNode + TableName() ITableNameContext + IGNORE() antlr.TerminalNode + WaitNowaitClause() IWaitNowaitClauseContext + AllAlterSpecification() []IAlterSpecificationContext + AlterSpecification(i int) IAlterSpecificationContext + PartitionDefinitions() IPartitionDefinitionsContext + ONLINE() antlr.TerminalNode + OFFLINE() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAlterTableContext differentiates from other interfaces. + IsAlterTableContext() +} + +type AlterTableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + intimeAction antlr.Token +} + +func NewEmptyAlterTableContext() *AlterTableContext { + var p = new(AlterTableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_alterTable + return p +} + +func InitEmptyAlterTableContext(p *AlterTableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_alterTable +} + +func (*AlterTableContext) IsAlterTableContext() {} + +func NewAlterTableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterTableContext { + var p = new(AlterTableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_alterTable + + return p +} + +func (s *AlterTableContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterTableContext) GetIntimeAction() antlr.Token { return s.intimeAction } + +func (s *AlterTableContext) SetIntimeAction(v antlr.Token) { s.intimeAction = v } + +func (s *AlterTableContext) ALTER() antlr.TerminalNode { + return s.GetToken(MySqlParserALTER, 0) +} + +func (s *AlterTableContext) TABLE() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLE, 0) +} + +func (s *AlterTableContext) TableName() ITableNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableNameContext) +} + +func (s *AlterTableContext) IGNORE() antlr.TerminalNode { + return s.GetToken(MySqlParserIGNORE, 0) +} + +func (s *AlterTableContext) WaitNowaitClause() IWaitNowaitClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWaitNowaitClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWaitNowaitClauseContext) +} + +func (s *AlterTableContext) AllAlterSpecification() []IAlterSpecificationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAlterSpecificationContext); ok { + len++ + } + } + + tst := make([]IAlterSpecificationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAlterSpecificationContext); ok { + tst[i] = t.(IAlterSpecificationContext) + i++ + } + } + + return tst +} + +func (s *AlterTableContext) AlterSpecification(i int) IAlterSpecificationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterSpecificationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAlterSpecificationContext) +} + +func (s *AlterTableContext) PartitionDefinitions() IPartitionDefinitionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionDefinitionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartitionDefinitionsContext) +} + +func (s *AlterTableContext) ONLINE() antlr.TerminalNode { + return s.GetToken(MySqlParserONLINE, 0) +} + +func (s *AlterTableContext) OFFLINE() antlr.TerminalNode { + return s.GetToken(MySqlParserOFFLINE, 0) +} + +func (s *AlterTableContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *AlterTableContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *AlterTableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterTableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterTableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterTable(s) + } +} + +func (s *AlterTableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterTable(s) + } +} + +func (p *MySqlParser) AlterTable() (localctx IAlterTableContext) { + localctx = NewAlterTableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 142, MySqlParserRULE_alterTable) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2455) + p.Match(MySqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2457) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserOFFLINE || _la == MySqlParserONLINE { + { + p.SetState(2456) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*AlterTableContext).intimeAction = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserOFFLINE || _la == MySqlParserONLINE) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*AlterTableContext).intimeAction = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(2460) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserIGNORE { + { + p.SetState(2459) + p.Match(MySqlParserIGNORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2462) + p.Match(MySqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2463) + p.TableName() + } + p.SetState(2465) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserNOWAIT || _la == MySqlParserWAIT { + { + p.SetState(2464) + p.WaitNowaitClause() + } + + } + p.SetState(2475) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 300, p.GetParserRuleContext()) == 1 { + { + p.SetState(2467) + p.AlterSpecification() + } + p.SetState(2472) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(2468) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2469) + p.AlterSpecification() + } + + p.SetState(2474) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(2478) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserPARTITION { + { + p.SetState(2477) + p.PartitionDefinitions() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterTablespaceContext is an interface to support dynamic dispatch. +type IAlterTablespaceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetObjectAction returns the objectAction token. + GetObjectAction() antlr.Token + + // SetObjectAction sets the objectAction token. + SetObjectAction(antlr.Token) + + // Getter signatures + ALTER() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + Uid() IUidContext + DATAFILE() antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + ENGINE() antlr.TerminalNode + EngineName() IEngineNameContext + ADD() antlr.TerminalNode + DROP() antlr.TerminalNode + INITIAL_SIZE() antlr.TerminalNode + AllEQUAL_SYMBOL() []antlr.TerminalNode + EQUAL_SYMBOL(i int) antlr.TerminalNode + FileSizeLiteral() IFileSizeLiteralContext + WAIT() antlr.TerminalNode + + // IsAlterTablespaceContext differentiates from other interfaces. + IsAlterTablespaceContext() +} + +type AlterTablespaceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + objectAction antlr.Token +} + +func NewEmptyAlterTablespaceContext() *AlterTablespaceContext { + var p = new(AlterTablespaceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_alterTablespace + return p +} + +func InitEmptyAlterTablespaceContext(p *AlterTablespaceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_alterTablespace +} + +func (*AlterTablespaceContext) IsAlterTablespaceContext() {} + +func NewAlterTablespaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterTablespaceContext { + var p = new(AlterTablespaceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_alterTablespace + + return p +} + +func (s *AlterTablespaceContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterTablespaceContext) GetObjectAction() antlr.Token { return s.objectAction } + +func (s *AlterTablespaceContext) SetObjectAction(v antlr.Token) { s.objectAction = v } + +func (s *AlterTablespaceContext) ALTER() antlr.TerminalNode { + return s.GetToken(MySqlParserALTER, 0) +} + +func (s *AlterTablespaceContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLESPACE, 0) +} + +func (s *AlterTablespaceContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *AlterTablespaceContext) DATAFILE() antlr.TerminalNode { + return s.GetToken(MySqlParserDATAFILE, 0) +} + +func (s *AlterTablespaceContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *AlterTablespaceContext) ENGINE() antlr.TerminalNode { + return s.GetToken(MySqlParserENGINE, 0) +} + +func (s *AlterTablespaceContext) EngineName() IEngineNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEngineNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEngineNameContext) +} + +func (s *AlterTablespaceContext) ADD() antlr.TerminalNode { + return s.GetToken(MySqlParserADD, 0) +} + +func (s *AlterTablespaceContext) DROP() antlr.TerminalNode { + return s.GetToken(MySqlParserDROP, 0) +} + +func (s *AlterTablespaceContext) INITIAL_SIZE() antlr.TerminalNode { + return s.GetToken(MySqlParserINITIAL_SIZE, 0) +} + +func (s *AlterTablespaceContext) AllEQUAL_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(MySqlParserEQUAL_SYMBOL) +} + +func (s *AlterTablespaceContext) EQUAL_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, i) +} + +func (s *AlterTablespaceContext) FileSizeLiteral() IFileSizeLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFileSizeLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFileSizeLiteralContext) +} + +func (s *AlterTablespaceContext) WAIT() antlr.TerminalNode { + return s.GetToken(MySqlParserWAIT, 0) +} + +func (s *AlterTablespaceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterTablespaceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterTablespaceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterTablespace(s) + } +} + +func (s *AlterTablespaceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterTablespace(s) + } +} + +func (p *MySqlParser) AlterTablespace() (localctx IAlterTablespaceContext) { + localctx = NewAlterTablespaceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 144, MySqlParserRULE_alterTablespace) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2480) + p.Match(MySqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2481) + p.Match(MySqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2482) + p.Uid() + } + { + p.SetState(2483) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*AlterTablespaceContext).objectAction = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserADD || _la == MySqlParserDROP) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*AlterTablespaceContext).objectAction = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2484) + p.Match(MySqlParserDATAFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2485) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2489) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserINITIAL_SIZE { + { + p.SetState(2486) + p.Match(MySqlParserINITIAL_SIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2487) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2488) + p.FileSizeLiteral() + } + + } + p.SetState(2492) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserWAIT { + { + p.SetState(2491) + p.Match(MySqlParserWAIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2494) + p.Match(MySqlParserENGINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2496) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(2495) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2498) + p.EngineName() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterViewContext is an interface to support dynamic dispatch. +type IAlterViewContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetAlgType returns the algType token. + GetAlgType() antlr.Token + + // GetSecContext returns the secContext token. + GetSecContext() antlr.Token + + // GetCheckOpt returns the checkOpt token. + GetCheckOpt() antlr.Token + + // SetAlgType sets the algType token. + SetAlgType(antlr.Token) + + // SetSecContext sets the secContext token. + SetSecContext(antlr.Token) + + // SetCheckOpt sets the checkOpt token. + SetCheckOpt(antlr.Token) + + // Getter signatures + ALTER() antlr.TerminalNode + VIEW() antlr.TerminalNode + FullId() IFullIdContext + AS() antlr.TerminalNode + SelectStatement() ISelectStatementContext + ALGORITHM() antlr.TerminalNode + EQUAL_SYMBOL() antlr.TerminalNode + OwnerStatement() IOwnerStatementContext + SQL() antlr.TerminalNode + SECURITY() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + UidList() IUidListContext + RR_BRACKET() antlr.TerminalNode + WITH() antlr.TerminalNode + CHECK() antlr.TerminalNode + OPTION() antlr.TerminalNode + UNDEFINED() antlr.TerminalNode + MERGE() antlr.TerminalNode + TEMPTABLE() antlr.TerminalNode + DEFINER() antlr.TerminalNode + INVOKER() antlr.TerminalNode + CASCADED() antlr.TerminalNode + LOCAL() antlr.TerminalNode + + // IsAlterViewContext differentiates from other interfaces. + IsAlterViewContext() +} + +type AlterViewContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + algType antlr.Token + secContext antlr.Token + checkOpt antlr.Token +} + +func NewEmptyAlterViewContext() *AlterViewContext { + var p = new(AlterViewContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_alterView + return p +} + +func InitEmptyAlterViewContext(p *AlterViewContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_alterView +} + +func (*AlterViewContext) IsAlterViewContext() {} + +func NewAlterViewContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterViewContext { + var p = new(AlterViewContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_alterView + + return p +} + +func (s *AlterViewContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterViewContext) GetAlgType() antlr.Token { return s.algType } + +func (s *AlterViewContext) GetSecContext() antlr.Token { return s.secContext } + +func (s *AlterViewContext) GetCheckOpt() antlr.Token { return s.checkOpt } + +func (s *AlterViewContext) SetAlgType(v antlr.Token) { s.algType = v } + +func (s *AlterViewContext) SetSecContext(v antlr.Token) { s.secContext = v } + +func (s *AlterViewContext) SetCheckOpt(v antlr.Token) { s.checkOpt = v } + +func (s *AlterViewContext) ALTER() antlr.TerminalNode { + return s.GetToken(MySqlParserALTER, 0) +} + +func (s *AlterViewContext) VIEW() antlr.TerminalNode { + return s.GetToken(MySqlParserVIEW, 0) +} + +func (s *AlterViewContext) FullId() IFullIdContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFullIdContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFullIdContext) +} + +func (s *AlterViewContext) AS() antlr.TerminalNode { + return s.GetToken(MySqlParserAS, 0) +} + +func (s *AlterViewContext) SelectStatement() ISelectStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelectStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelectStatementContext) +} + +func (s *AlterViewContext) ALGORITHM() antlr.TerminalNode { + return s.GetToken(MySqlParserALGORITHM, 0) +} + +func (s *AlterViewContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *AlterViewContext) OwnerStatement() IOwnerStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOwnerStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOwnerStatementContext) +} + +func (s *AlterViewContext) SQL() antlr.TerminalNode { + return s.GetToken(MySqlParserSQL, 0) +} + +func (s *AlterViewContext) SECURITY() antlr.TerminalNode { + return s.GetToken(MySqlParserSECURITY, 0) +} + +func (s *AlterViewContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *AlterViewContext) UidList() IUidListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidListContext) +} + +func (s *AlterViewContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *AlterViewContext) WITH() antlr.TerminalNode { + return s.GetToken(MySqlParserWITH, 0) +} + +func (s *AlterViewContext) CHECK() antlr.TerminalNode { + return s.GetToken(MySqlParserCHECK, 0) +} + +func (s *AlterViewContext) OPTION() antlr.TerminalNode { + return s.GetToken(MySqlParserOPTION, 0) +} + +func (s *AlterViewContext) UNDEFINED() antlr.TerminalNode { + return s.GetToken(MySqlParserUNDEFINED, 0) +} + +func (s *AlterViewContext) MERGE() antlr.TerminalNode { + return s.GetToken(MySqlParserMERGE, 0) +} + +func (s *AlterViewContext) TEMPTABLE() antlr.TerminalNode { + return s.GetToken(MySqlParserTEMPTABLE, 0) +} + +func (s *AlterViewContext) DEFINER() antlr.TerminalNode { + return s.GetToken(MySqlParserDEFINER, 0) +} + +func (s *AlterViewContext) INVOKER() antlr.TerminalNode { + return s.GetToken(MySqlParserINVOKER, 0) +} + +func (s *AlterViewContext) CASCADED() antlr.TerminalNode { + return s.GetToken(MySqlParserCASCADED, 0) +} + +func (s *AlterViewContext) LOCAL() antlr.TerminalNode { + return s.GetToken(MySqlParserLOCAL, 0) +} + +func (s *AlterViewContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterViewContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterViewContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterView(s) + } +} + +func (s *AlterViewContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterView(s) + } +} + +func (p *MySqlParser) AlterView() (localctx IAlterViewContext) { + localctx = NewAlterViewContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 146, MySqlParserRULE_alterView) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2500) + p.Match(MySqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2504) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserALGORITHM { + { + p.SetState(2501) + p.Match(MySqlParserALGORITHM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2502) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2503) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*AlterViewContext).algType = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserMERGE || _la == MySqlParserTEMPTABLE || _la == MySqlParserUNDEFINED) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*AlterViewContext).algType = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(2507) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserDEFINER { + { + p.SetState(2506) + p.OwnerStatement() + } + + } + p.SetState(2512) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserSQL { + { + p.SetState(2509) + p.Match(MySqlParserSQL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2510) + p.Match(MySqlParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2511) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*AlterViewContext).secContext = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserDEFINER || _la == MySqlParserINVOKER) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*AlterViewContext).secContext = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(2514) + p.Match(MySqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2515) + p.FullId() + } + p.SetState(2520) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserLR_BRACKET { + { + p.SetState(2516) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2517) + p.UidList() + } + { + p.SetState(2518) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2522) + p.Match(MySqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2523) + p.SelectStatement() + } + p.SetState(2530) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 310, p.GetParserRuleContext()) == 1 { + { + p.SetState(2524) + p.Match(MySqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2526) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserCASCADED || _la == MySqlParserLOCAL { + { + p.SetState(2525) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*AlterViewContext).checkOpt = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserCASCADED || _la == MySqlParserLOCAL) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*AlterViewContext).checkOpt = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(2528) + p.Match(MySqlParserCHECK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2529) + p.Match(MySqlParserOPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterSpecificationContext is an interface to support dynamic dispatch. +type IAlterSpecificationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsAlterSpecificationContext differentiates from other interfaces. + IsAlterSpecificationContext() +} + +type AlterSpecificationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterSpecificationContext() *AlterSpecificationContext { + var p = new(AlterSpecificationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_alterSpecification + return p +} + +func InitEmptyAlterSpecificationContext(p *AlterSpecificationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_alterSpecification +} + +func (*AlterSpecificationContext) IsAlterSpecificationContext() {} + +func NewAlterSpecificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterSpecificationContext { + var p = new(AlterSpecificationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_alterSpecification + + return p +} + +func (s *AlterSpecificationContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterSpecificationContext) CopyAll(ctx *AlterSpecificationContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *AlterSpecificationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterSpecificationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type AlterByAlterColumnDefaultContext struct { + AlterSpecificationContext +} + +func NewAlterByAlterColumnDefaultContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByAlterColumnDefaultContext { + var p = new(AlterByAlterColumnDefaultContext) + + InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSpecificationContext)) + + return p +} + +func (s *AlterByAlterColumnDefaultContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByAlterColumnDefaultContext) ALTER() antlr.TerminalNode { + return s.GetToken(MySqlParserALTER, 0) +} + +func (s *AlterByAlterColumnDefaultContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *AlterByAlterColumnDefaultContext) SET() antlr.TerminalNode { + return s.GetToken(MySqlParserSET, 0) +} + +func (s *AlterByAlterColumnDefaultContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(MySqlParserDEFAULT, 0) +} + +func (s *AlterByAlterColumnDefaultContext) DROP() antlr.TerminalNode { + return s.GetToken(MySqlParserDROP, 0) +} + +func (s *AlterByAlterColumnDefaultContext) COLUMN() antlr.TerminalNode { + return s.GetToken(MySqlParserCOLUMN, 0) +} + +func (s *AlterByAlterColumnDefaultContext) VISIBLE() antlr.TerminalNode { + return s.GetToken(MySqlParserVISIBLE, 0) +} + +func (s *AlterByAlterColumnDefaultContext) INVISIBLE() antlr.TerminalNode { + return s.GetToken(MySqlParserINVISIBLE, 0) +} + +func (s *AlterByAlterColumnDefaultContext) StringLiteral() IStringLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringLiteralContext) +} + +func (s *AlterByAlterColumnDefaultContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *AlterByAlterColumnDefaultContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *AlterByAlterColumnDefaultContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *AlterByAlterColumnDefaultContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByAlterColumnDefault(s) + } +} + +func (s *AlterByAlterColumnDefaultContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByAlterColumnDefault(s) + } +} + +type AlterByDisableKeysContext struct { + AlterSpecificationContext +} + +func NewAlterByDisableKeysContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByDisableKeysContext { + var p = new(AlterByDisableKeysContext) + + InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSpecificationContext)) + + return p +} + +func (s *AlterByDisableKeysContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByDisableKeysContext) DISABLE() antlr.TerminalNode { + return s.GetToken(MySqlParserDISABLE, 0) +} + +func (s *AlterByDisableKeysContext) KEYS() antlr.TerminalNode { + return s.GetToken(MySqlParserKEYS, 0) +} + +func (s *AlterByDisableKeysContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByDisableKeys(s) + } +} + +func (s *AlterByDisableKeysContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByDisableKeys(s) + } +} + +type AlterByDefaultCharsetContext struct { + AlterSpecificationContext +} + +func NewAlterByDefaultCharsetContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByDefaultCharsetContext { + var p = new(AlterByDefaultCharsetContext) + + InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSpecificationContext)) + + return p +} + +func (s *AlterByDefaultCharsetContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByDefaultCharsetContext) CHARACTER() antlr.TerminalNode { + return s.GetToken(MySqlParserCHARACTER, 0) +} + +func (s *AlterByDefaultCharsetContext) SET() antlr.TerminalNode { + return s.GetToken(MySqlParserSET, 0) +} + +func (s *AlterByDefaultCharsetContext) AllEQUAL_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(MySqlParserEQUAL_SYMBOL) +} + +func (s *AlterByDefaultCharsetContext) EQUAL_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, i) +} + +func (s *AlterByDefaultCharsetContext) CharsetName() ICharsetNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICharsetNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICharsetNameContext) +} + +func (s *AlterByDefaultCharsetContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(MySqlParserDEFAULT, 0) +} + +func (s *AlterByDefaultCharsetContext) COLLATE() antlr.TerminalNode { + return s.GetToken(MySqlParserCOLLATE, 0) +} + +func (s *AlterByDefaultCharsetContext) CollationName() ICollationNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICollationNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICollationNameContext) +} + +func (s *AlterByDefaultCharsetContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByDefaultCharset(s) + } +} + +func (s *AlterByDefaultCharsetContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByDefaultCharset(s) + } +} + +type AlterByRenameColumnContext struct { + AlterSpecificationContext + oldColumn IUidContext + newColumn IUidContext +} + +func NewAlterByRenameColumnContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByRenameColumnContext { + var p = new(AlterByRenameColumnContext) + + InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSpecificationContext)) + + return p +} + +func (s *AlterByRenameColumnContext) GetOldColumn() IUidContext { return s.oldColumn } + +func (s *AlterByRenameColumnContext) GetNewColumn() IUidContext { return s.newColumn } + +func (s *AlterByRenameColumnContext) SetOldColumn(v IUidContext) { s.oldColumn = v } + +func (s *AlterByRenameColumnContext) SetNewColumn(v IUidContext) { s.newColumn = v } + +func (s *AlterByRenameColumnContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByRenameColumnContext) RENAME() antlr.TerminalNode { + return s.GetToken(MySqlParserRENAME, 0) +} + +func (s *AlterByRenameColumnContext) COLUMN() antlr.TerminalNode { + return s.GetToken(MySqlParserCOLUMN, 0) +} + +func (s *AlterByRenameColumnContext) TO() antlr.TerminalNode { + return s.GetToken(MySqlParserTO, 0) +} + +func (s *AlterByRenameColumnContext) AllUid() []IUidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUidContext); ok { + len++ + } + } + + tst := make([]IUidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUidContext); ok { + tst[i] = t.(IUidContext) + i++ + } + } + + return tst +} + +func (s *AlterByRenameColumnContext) Uid(i int) IUidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *AlterByRenameColumnContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByRenameColumn(s) + } +} + +func (s *AlterByRenameColumnContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByRenameColumn(s) + } +} + +type AlterByConvertCharsetContext struct { + AlterSpecificationContext +} + +func NewAlterByConvertCharsetContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByConvertCharsetContext { + var p = new(AlterByConvertCharsetContext) + + InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSpecificationContext)) + + return p +} + +func (s *AlterByConvertCharsetContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByConvertCharsetContext) CONVERT() antlr.TerminalNode { + return s.GetToken(MySqlParserCONVERT, 0) +} + +func (s *AlterByConvertCharsetContext) TO() antlr.TerminalNode { + return s.GetToken(MySqlParserTO, 0) +} + +func (s *AlterByConvertCharsetContext) CharsetName() ICharsetNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICharsetNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICharsetNameContext) +} + +func (s *AlterByConvertCharsetContext) CHARSET() antlr.TerminalNode { + return s.GetToken(MySqlParserCHARSET, 0) +} + +func (s *AlterByConvertCharsetContext) CHARACTER() antlr.TerminalNode { + return s.GetToken(MySqlParserCHARACTER, 0) +} + +func (s *AlterByConvertCharsetContext) SET() antlr.TerminalNode { + return s.GetToken(MySqlParserSET, 0) +} + +func (s *AlterByConvertCharsetContext) COLLATE() antlr.TerminalNode { + return s.GetToken(MySqlParserCOLLATE, 0) +} + +func (s *AlterByConvertCharsetContext) CollationName() ICollationNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICollationNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICollationNameContext) +} + +func (s *AlterByConvertCharsetContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByConvertCharset(s) + } +} + +func (s *AlterByConvertCharsetContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByConvertCharset(s) + } +} + +type AlterByAddForeignKeyContext struct { + AlterSpecificationContext + name IUidContext + indexName IUidContext +} + +func NewAlterByAddForeignKeyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByAddForeignKeyContext { + var p = new(AlterByAddForeignKeyContext) + + InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSpecificationContext)) + + return p +} + +func (s *AlterByAddForeignKeyContext) GetName() IUidContext { return s.name } + +func (s *AlterByAddForeignKeyContext) GetIndexName() IUidContext { return s.indexName } + +func (s *AlterByAddForeignKeyContext) SetName(v IUidContext) { s.name = v } + +func (s *AlterByAddForeignKeyContext) SetIndexName(v IUidContext) { s.indexName = v } + +func (s *AlterByAddForeignKeyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByAddForeignKeyContext) ADD() antlr.TerminalNode { + return s.GetToken(MySqlParserADD, 0) +} + +func (s *AlterByAddForeignKeyContext) FOREIGN() antlr.TerminalNode { + return s.GetToken(MySqlParserFOREIGN, 0) +} + +func (s *AlterByAddForeignKeyContext) KEY() antlr.TerminalNode { + return s.GetToken(MySqlParserKEY, 0) +} + +func (s *AlterByAddForeignKeyContext) IndexColumnNames() IIndexColumnNamesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexColumnNamesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndexColumnNamesContext) +} + +func (s *AlterByAddForeignKeyContext) ReferenceDefinition() IReferenceDefinitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReferenceDefinitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReferenceDefinitionContext) +} + +func (s *AlterByAddForeignKeyContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(MySqlParserCONSTRAINT, 0) +} + +func (s *AlterByAddForeignKeyContext) AllUid() []IUidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUidContext); ok { + len++ + } + } + + tst := make([]IUidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUidContext); ok { + tst[i] = t.(IUidContext) + i++ + } + } + + return tst +} + +func (s *AlterByAddForeignKeyContext) Uid(i int) IUidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *AlterByAddForeignKeyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByAddForeignKey(s) + } +} + +func (s *AlterByAddForeignKeyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByAddForeignKey(s) + } +} + +type AlterByRenameIndexContext struct { + AlterSpecificationContext + indexFormat antlr.Token +} + +func NewAlterByRenameIndexContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByRenameIndexContext { + var p = new(AlterByRenameIndexContext) + + InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSpecificationContext)) + + return p +} + +func (s *AlterByRenameIndexContext) GetIndexFormat() antlr.Token { return s.indexFormat } + +func (s *AlterByRenameIndexContext) SetIndexFormat(v antlr.Token) { s.indexFormat = v } + +func (s *AlterByRenameIndexContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByRenameIndexContext) RENAME() antlr.TerminalNode { + return s.GetToken(MySqlParserRENAME, 0) +} + +func (s *AlterByRenameIndexContext) AllUid() []IUidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUidContext); ok { + len++ + } + } + + tst := make([]IUidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUidContext); ok { + tst[i] = t.(IUidContext) + i++ + } + } + + return tst +} + +func (s *AlterByRenameIndexContext) Uid(i int) IUidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *AlterByRenameIndexContext) TO() antlr.TerminalNode { + return s.GetToken(MySqlParserTO, 0) +} + +func (s *AlterByRenameIndexContext) INDEX() antlr.TerminalNode { + return s.GetToken(MySqlParserINDEX, 0) +} + +func (s *AlterByRenameIndexContext) KEY() antlr.TerminalNode { + return s.GetToken(MySqlParserKEY, 0) +} + +func (s *AlterByRenameIndexContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByRenameIndex(s) + } +} + +func (s *AlterByRenameIndexContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByRenameIndex(s) + } +} + +type AlterByRenameContext struct { + AlterSpecificationContext + renameFormat antlr.Token +} + +func NewAlterByRenameContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByRenameContext { + var p = new(AlterByRenameContext) + + InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSpecificationContext)) + + return p +} + +func (s *AlterByRenameContext) GetRenameFormat() antlr.Token { return s.renameFormat } + +func (s *AlterByRenameContext) SetRenameFormat(v antlr.Token) { s.renameFormat = v } + +func (s *AlterByRenameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByRenameContext) RENAME() antlr.TerminalNode { + return s.GetToken(MySqlParserRENAME, 0) +} + +func (s *AlterByRenameContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *AlterByRenameContext) FullId() IFullIdContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFullIdContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFullIdContext) +} + +func (s *AlterByRenameContext) TO() antlr.TerminalNode { + return s.GetToken(MySqlParserTO, 0) +} + +func (s *AlterByRenameContext) AS() antlr.TerminalNode { + return s.GetToken(MySqlParserAS, 0) +} + +func (s *AlterByRenameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByRename(s) + } +} + +func (s *AlterByRenameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByRename(s) + } +} + +type AlterByImportTablespaceContext struct { + AlterSpecificationContext +} + +func NewAlterByImportTablespaceContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByImportTablespaceContext { + var p = new(AlterByImportTablespaceContext) + + InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSpecificationContext)) + + return p +} + +func (s *AlterByImportTablespaceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByImportTablespaceContext) IMPORT() antlr.TerminalNode { + return s.GetToken(MySqlParserIMPORT, 0) +} + +func (s *AlterByImportTablespaceContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLESPACE, 0) +} + +func (s *AlterByImportTablespaceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByImportTablespace(s) + } +} + +func (s *AlterByImportTablespaceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByImportTablespace(s) + } +} + +type AlterByAddDefinitionsContext struct { + AlterSpecificationContext +} + +func NewAlterByAddDefinitionsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByAddDefinitionsContext { + var p = new(AlterByAddDefinitionsContext) + + InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSpecificationContext)) + + return p +} + +func (s *AlterByAddDefinitionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByAddDefinitionsContext) ADD() antlr.TerminalNode { + return s.GetToken(MySqlParserADD, 0) +} + +func (s *AlterByAddDefinitionsContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *AlterByAddDefinitionsContext) AllCreateDefinition() []ICreateDefinitionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICreateDefinitionContext); ok { + len++ + } + } + + tst := make([]ICreateDefinitionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICreateDefinitionContext); ok { + tst[i] = t.(ICreateDefinitionContext) + i++ + } + } + + return tst +} + +func (s *AlterByAddDefinitionsContext) CreateDefinition(i int) ICreateDefinitionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateDefinitionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICreateDefinitionContext) +} + +func (s *AlterByAddDefinitionsContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *AlterByAddDefinitionsContext) COLUMN() antlr.TerminalNode { + return s.GetToken(MySqlParserCOLUMN, 0) +} + +func (s *AlterByAddDefinitionsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *AlterByAddDefinitionsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *AlterByAddDefinitionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByAddDefinitions(s) + } +} + +func (s *AlterByAddDefinitionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByAddDefinitions(s) + } +} + +type AlterByAlterCheckTableConstraintContext struct { + AlterSpecificationContext + name IUidContext +} + +func NewAlterByAlterCheckTableConstraintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByAlterCheckTableConstraintContext { + var p = new(AlterByAlterCheckTableConstraintContext) + + InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSpecificationContext)) + + return p +} + +func (s *AlterByAlterCheckTableConstraintContext) GetName() IUidContext { return s.name } + +func (s *AlterByAlterCheckTableConstraintContext) SetName(v IUidContext) { s.name = v } + +func (s *AlterByAlterCheckTableConstraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByAlterCheckTableConstraintContext) ALTER() antlr.TerminalNode { + return s.GetToken(MySqlParserALTER, 0) +} + +func (s *AlterByAlterCheckTableConstraintContext) CHECK() antlr.TerminalNode { + return s.GetToken(MySqlParserCHECK, 0) +} + +func (s *AlterByAlterCheckTableConstraintContext) AllUid() []IUidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUidContext); ok { + len++ + } + } + + tst := make([]IUidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUidContext); ok { + tst[i] = t.(IUidContext) + i++ + } + } + + return tst +} + +func (s *AlterByAlterCheckTableConstraintContext) Uid(i int) IUidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *AlterByAlterCheckTableConstraintContext) StringLiteral() IStringLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringLiteralContext) +} + +func (s *AlterByAlterCheckTableConstraintContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *AlterByAlterCheckTableConstraintContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *AlterByAlterCheckTableConstraintContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *AlterByAlterCheckTableConstraintContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(MySqlParserCONSTRAINT, 0) +} + +func (s *AlterByAlterCheckTableConstraintContext) NOT() antlr.TerminalNode { + return s.GetToken(MySqlParserNOT, 0) +} + +func (s *AlterByAlterCheckTableConstraintContext) ENFORCED() antlr.TerminalNode { + return s.GetToken(MySqlParserENFORCED, 0) +} + +func (s *AlterByAlterCheckTableConstraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByAlterCheckTableConstraint(s) + } +} + +func (s *AlterByAlterCheckTableConstraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByAlterCheckTableConstraint(s) + } +} + +type AlterByDropConstraintCheckContext struct { + AlterSpecificationContext +} + +func NewAlterByDropConstraintCheckContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByDropConstraintCheckContext { + var p = new(AlterByDropConstraintCheckContext) + + InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSpecificationContext)) + + return p +} + +func (s *AlterByDropConstraintCheckContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByDropConstraintCheckContext) DROP() antlr.TerminalNode { + return s.GetToken(MySqlParserDROP, 0) +} + +func (s *AlterByDropConstraintCheckContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *AlterByDropConstraintCheckContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(MySqlParserCONSTRAINT, 0) +} + +func (s *AlterByDropConstraintCheckContext) CHECK() antlr.TerminalNode { + return s.GetToken(MySqlParserCHECK, 0) +} + +func (s *AlterByDropConstraintCheckContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByDropConstraintCheck(s) + } +} + +func (s *AlterByDropConstraintCheckContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByDropConstraintCheck(s) + } +} + +type AlterByAddColumnsContext struct { + AlterSpecificationContext +} + +func NewAlterByAddColumnsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByAddColumnsContext { + var p = new(AlterByAddColumnsContext) + + InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSpecificationContext)) + + return p +} + +func (s *AlterByAddColumnsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByAddColumnsContext) ADD() antlr.TerminalNode { + return s.GetToken(MySqlParserADD, 0) +} + +func (s *AlterByAddColumnsContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *AlterByAddColumnsContext) AllUid() []IUidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUidContext); ok { + len++ + } + } + + tst := make([]IUidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUidContext); ok { + tst[i] = t.(IUidContext) + i++ + } + } + + return tst +} + +func (s *AlterByAddColumnsContext) Uid(i int) IUidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *AlterByAddColumnsContext) AllColumnDefinition() []IColumnDefinitionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumnDefinitionContext); ok { + len++ + } + } + + tst := make([]IColumnDefinitionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumnDefinitionContext); ok { + tst[i] = t.(IColumnDefinitionContext) + i++ + } + } + + return tst +} + +func (s *AlterByAddColumnsContext) ColumnDefinition(i int) IColumnDefinitionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnDefinitionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumnDefinitionContext) +} + +func (s *AlterByAddColumnsContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *AlterByAddColumnsContext) COLUMN() antlr.TerminalNode { + return s.GetToken(MySqlParserCOLUMN, 0) +} + +func (s *AlterByAddColumnsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *AlterByAddColumnsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *AlterByAddColumnsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByAddColumns(s) + } +} + +func (s *AlterByAddColumnsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByAddColumns(s) + } +} + +type AlterByAlterIndexVisibilityContext struct { + AlterSpecificationContext +} + +func NewAlterByAlterIndexVisibilityContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByAlterIndexVisibilityContext { + var p = new(AlterByAlterIndexVisibilityContext) + + InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSpecificationContext)) + + return p +} + +func (s *AlterByAlterIndexVisibilityContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByAlterIndexVisibilityContext) ALTER() antlr.TerminalNode { + return s.GetToken(MySqlParserALTER, 0) +} + +func (s *AlterByAlterIndexVisibilityContext) INDEX() antlr.TerminalNode { + return s.GetToken(MySqlParserINDEX, 0) +} + +func (s *AlterByAlterIndexVisibilityContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *AlterByAlterIndexVisibilityContext) VISIBLE() antlr.TerminalNode { + return s.GetToken(MySqlParserVISIBLE, 0) +} + +func (s *AlterByAlterIndexVisibilityContext) INVISIBLE() antlr.TerminalNode { + return s.GetToken(MySqlParserINVISIBLE, 0) +} + +func (s *AlterByAlterIndexVisibilityContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByAlterIndexVisibility(s) + } +} + +func (s *AlterByAlterIndexVisibilityContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByAlterIndexVisibility(s) + } +} + +type AlterByDropForeignKeyContext struct { + AlterSpecificationContext +} + +func NewAlterByDropForeignKeyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByDropForeignKeyContext { + var p = new(AlterByDropForeignKeyContext) + + InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSpecificationContext)) + + return p +} + +func (s *AlterByDropForeignKeyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByDropForeignKeyContext) DROP() antlr.TerminalNode { + return s.GetToken(MySqlParserDROP, 0) +} + +func (s *AlterByDropForeignKeyContext) FOREIGN() antlr.TerminalNode { + return s.GetToken(MySqlParserFOREIGN, 0) +} + +func (s *AlterByDropForeignKeyContext) KEY() antlr.TerminalNode { + return s.GetToken(MySqlParserKEY, 0) +} + +func (s *AlterByDropForeignKeyContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *AlterByDropForeignKeyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByDropForeignKey(s) + } +} + +func (s *AlterByDropForeignKeyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByDropForeignKey(s) + } +} + +type AlterByAddCheckTableConstraintContext struct { + AlterSpecificationContext + name IUidContext +} + +func NewAlterByAddCheckTableConstraintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByAddCheckTableConstraintContext { + var p = new(AlterByAddCheckTableConstraintContext) + + InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSpecificationContext)) + + return p +} + +func (s *AlterByAddCheckTableConstraintContext) GetName() IUidContext { return s.name } + +func (s *AlterByAddCheckTableConstraintContext) SetName(v IUidContext) { s.name = v } + +func (s *AlterByAddCheckTableConstraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByAddCheckTableConstraintContext) ADD() antlr.TerminalNode { + return s.GetToken(MySqlParserADD, 0) +} + +func (s *AlterByAddCheckTableConstraintContext) CHECK() antlr.TerminalNode { + return s.GetToken(MySqlParserCHECK, 0) +} + +func (s *AlterByAddCheckTableConstraintContext) AllUid() []IUidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUidContext); ok { + len++ + } + } + + tst := make([]IUidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUidContext); ok { + tst[i] = t.(IUidContext) + i++ + } + } + + return tst +} + +func (s *AlterByAddCheckTableConstraintContext) Uid(i int) IUidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *AlterByAddCheckTableConstraintContext) StringLiteral() IStringLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringLiteralContext) +} + +func (s *AlterByAddCheckTableConstraintContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *AlterByAddCheckTableConstraintContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *AlterByAddCheckTableConstraintContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *AlterByAddCheckTableConstraintContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(MySqlParserCONSTRAINT, 0) +} + +func (s *AlterByAddCheckTableConstraintContext) NOT() antlr.TerminalNode { + return s.GetToken(MySqlParserNOT, 0) +} + +func (s *AlterByAddCheckTableConstraintContext) ENFORCED() antlr.TerminalNode { + return s.GetToken(MySqlParserENFORCED, 0) +} + +func (s *AlterByAddCheckTableConstraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByAddCheckTableConstraint(s) + } +} + +func (s *AlterByAddCheckTableConstraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByAddCheckTableConstraint(s) + } +} + +type AlterPartitionContext struct { + AlterSpecificationContext +} + +func NewAlterPartitionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterPartitionContext { + var p = new(AlterPartitionContext) + + InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSpecificationContext)) + + return p +} + +func (s *AlterPartitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterPartitionContext) AlterPartitionSpecification() IAlterPartitionSpecificationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterPartitionSpecificationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterPartitionSpecificationContext) +} + +func (s *AlterPartitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterPartition(s) + } +} + +func (s *AlterPartitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterPartition(s) + } +} + +type AlterByAddIndexContext struct { + AlterSpecificationContext + indexFormat antlr.Token +} + +func NewAlterByAddIndexContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByAddIndexContext { + var p = new(AlterByAddIndexContext) + + InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSpecificationContext)) + + return p +} + +func (s *AlterByAddIndexContext) GetIndexFormat() antlr.Token { return s.indexFormat } + +func (s *AlterByAddIndexContext) SetIndexFormat(v antlr.Token) { s.indexFormat = v } + +func (s *AlterByAddIndexContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByAddIndexContext) ADD() antlr.TerminalNode { + return s.GetToken(MySqlParserADD, 0) +} + +func (s *AlterByAddIndexContext) IndexColumnNames() IIndexColumnNamesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexColumnNamesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndexColumnNamesContext) +} + +func (s *AlterByAddIndexContext) INDEX() antlr.TerminalNode { + return s.GetToken(MySqlParserINDEX, 0) +} + +func (s *AlterByAddIndexContext) KEY() antlr.TerminalNode { + return s.GetToken(MySqlParserKEY, 0) +} + +func (s *AlterByAddIndexContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *AlterByAddIndexContext) IndexType() IIndexTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndexTypeContext) +} + +func (s *AlterByAddIndexContext) AllIndexOption() []IIndexOptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIndexOptionContext); ok { + len++ + } + } + + tst := make([]IIndexOptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIndexOptionContext); ok { + tst[i] = t.(IIndexOptionContext) + i++ + } + } + + return tst +} + +func (s *AlterByAddIndexContext) IndexOption(i int) IIndexOptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexOptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIndexOptionContext) +} + +func (s *AlterByAddIndexContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByAddIndex(s) + } +} + +func (s *AlterByAddIndexContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByAddIndex(s) + } +} + +type AlterByDropColumnContext struct { + AlterSpecificationContext +} + +func NewAlterByDropColumnContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByDropColumnContext { + var p = new(AlterByDropColumnContext) + + InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSpecificationContext)) + + return p +} + +func (s *AlterByDropColumnContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByDropColumnContext) DROP() antlr.TerminalNode { + return s.GetToken(MySqlParserDROP, 0) +} + +func (s *AlterByDropColumnContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *AlterByDropColumnContext) COLUMN() antlr.TerminalNode { + return s.GetToken(MySqlParserCOLUMN, 0) +} + +func (s *AlterByDropColumnContext) RESTRICT() antlr.TerminalNode { + return s.GetToken(MySqlParserRESTRICT, 0) +} + +func (s *AlterByDropColumnContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByDropColumn(s) + } +} + +func (s *AlterByDropColumnContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByDropColumn(s) + } +} + +type AlterByChangeDefaultContext struct { + AlterSpecificationContext +} + +func NewAlterByChangeDefaultContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByChangeDefaultContext { + var p = new(AlterByChangeDefaultContext) + + InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSpecificationContext)) + + return p +} + +func (s *AlterByChangeDefaultContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByChangeDefaultContext) ALTER() antlr.TerminalNode { + return s.GetToken(MySqlParserALTER, 0) +} + +func (s *AlterByChangeDefaultContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *AlterByChangeDefaultContext) SET() antlr.TerminalNode { + return s.GetToken(MySqlParserSET, 0) +} + +func (s *AlterByChangeDefaultContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(MySqlParserDEFAULT, 0) +} + +func (s *AlterByChangeDefaultContext) DefaultValue() IDefaultValueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefaultValueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefaultValueContext) +} + +func (s *AlterByChangeDefaultContext) DROP() antlr.TerminalNode { + return s.GetToken(MySqlParserDROP, 0) +} + +func (s *AlterByChangeDefaultContext) COLUMN() antlr.TerminalNode { + return s.GetToken(MySqlParserCOLUMN, 0) +} + +func (s *AlterByChangeDefaultContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByChangeDefault(s) + } +} + +func (s *AlterByChangeDefaultContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByChangeDefault(s) + } +} + +type AlterByForceContext struct { + AlterSpecificationContext +} + +func NewAlterByForceContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByForceContext { + var p = new(AlterByForceContext) + + InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSpecificationContext)) + + return p +} + +func (s *AlterByForceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByForceContext) FORCE() antlr.TerminalNode { + return s.GetToken(MySqlParserFORCE, 0) +} + +func (s *AlterByForceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByForce(s) + } +} + +func (s *AlterByForceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByForce(s) + } +} + +type AlterByAddSpecialIndexContext struct { + AlterSpecificationContext + keyType antlr.Token + indexFormat antlr.Token +} + +func NewAlterByAddSpecialIndexContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByAddSpecialIndexContext { + var p = new(AlterByAddSpecialIndexContext) + + InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSpecificationContext)) + + return p +} + +func (s *AlterByAddSpecialIndexContext) GetKeyType() antlr.Token { return s.keyType } + +func (s *AlterByAddSpecialIndexContext) GetIndexFormat() antlr.Token { return s.indexFormat } + +func (s *AlterByAddSpecialIndexContext) SetKeyType(v antlr.Token) { s.keyType = v } + +func (s *AlterByAddSpecialIndexContext) SetIndexFormat(v antlr.Token) { s.indexFormat = v } + +func (s *AlterByAddSpecialIndexContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByAddSpecialIndexContext) ADD() antlr.TerminalNode { + return s.GetToken(MySqlParserADD, 0) +} + +func (s *AlterByAddSpecialIndexContext) IndexColumnNames() IIndexColumnNamesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexColumnNamesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndexColumnNamesContext) +} + +func (s *AlterByAddSpecialIndexContext) FULLTEXT() antlr.TerminalNode { + return s.GetToken(MySqlParserFULLTEXT, 0) +} + +func (s *AlterByAddSpecialIndexContext) SPATIAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSPATIAL, 0) +} + +func (s *AlterByAddSpecialIndexContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *AlterByAddSpecialIndexContext) AllIndexOption() []IIndexOptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIndexOptionContext); ok { + len++ + } + } + + tst := make([]IIndexOptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIndexOptionContext); ok { + tst[i] = t.(IIndexOptionContext) + i++ + } + } + + return tst +} + +func (s *AlterByAddSpecialIndexContext) IndexOption(i int) IIndexOptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexOptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIndexOptionContext) +} + +func (s *AlterByAddSpecialIndexContext) INDEX() antlr.TerminalNode { + return s.GetToken(MySqlParserINDEX, 0) +} + +func (s *AlterByAddSpecialIndexContext) KEY() antlr.TerminalNode { + return s.GetToken(MySqlParserKEY, 0) +} + +func (s *AlterByAddSpecialIndexContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByAddSpecialIndex(s) + } +} + +func (s *AlterByAddSpecialIndexContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByAddSpecialIndex(s) + } +} + +type AlterByModifyColumnContext struct { + AlterSpecificationContext +} + +func NewAlterByModifyColumnContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByModifyColumnContext { + var p = new(AlterByModifyColumnContext) + + InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSpecificationContext)) + + return p +} + +func (s *AlterByModifyColumnContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByModifyColumnContext) MODIFY() antlr.TerminalNode { + return s.GetToken(MySqlParserMODIFY, 0) +} + +func (s *AlterByModifyColumnContext) AllUid() []IUidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUidContext); ok { + len++ + } + } + + tst := make([]IUidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUidContext); ok { + tst[i] = t.(IUidContext) + i++ + } + } + + return tst +} + +func (s *AlterByModifyColumnContext) Uid(i int) IUidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *AlterByModifyColumnContext) ColumnDefinition() IColumnDefinitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnDefinitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnDefinitionContext) +} + +func (s *AlterByModifyColumnContext) COLUMN() antlr.TerminalNode { + return s.GetToken(MySqlParserCOLUMN, 0) +} + +func (s *AlterByModifyColumnContext) FIRST() antlr.TerminalNode { + return s.GetToken(MySqlParserFIRST, 0) +} + +func (s *AlterByModifyColumnContext) AFTER() antlr.TerminalNode { + return s.GetToken(MySqlParserAFTER, 0) +} + +func (s *AlterByModifyColumnContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByModifyColumn(s) + } +} + +func (s *AlterByModifyColumnContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByModifyColumn(s) + } +} + +type AlterByTableOptionContext struct { + AlterSpecificationContext +} + +func NewAlterByTableOptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByTableOptionContext { + var p = new(AlterByTableOptionContext) + + InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSpecificationContext)) + + return p +} + +func (s *AlterByTableOptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByTableOptionContext) AllTableOption() []ITableOptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITableOptionContext); ok { + len++ + } + } + + tst := make([]ITableOptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITableOptionContext); ok { + tst[i] = t.(ITableOptionContext) + i++ + } + } + + return tst +} + +func (s *AlterByTableOptionContext) TableOption(i int) ITableOptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableOptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITableOptionContext) +} + +func (s *AlterByTableOptionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *AlterByTableOptionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *AlterByTableOptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByTableOption(s) + } +} + +func (s *AlterByTableOptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByTableOption(s) + } +} + +type AlterByDropPrimaryKeyContext struct { + AlterSpecificationContext +} + +func NewAlterByDropPrimaryKeyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByDropPrimaryKeyContext { + var p = new(AlterByDropPrimaryKeyContext) + + InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSpecificationContext)) + + return p +} + +func (s *AlterByDropPrimaryKeyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByDropPrimaryKeyContext) DROP() antlr.TerminalNode { + return s.GetToken(MySqlParserDROP, 0) +} + +func (s *AlterByDropPrimaryKeyContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(MySqlParserPRIMARY, 0) +} + +func (s *AlterByDropPrimaryKeyContext) KEY() antlr.TerminalNode { + return s.GetToken(MySqlParserKEY, 0) +} + +func (s *AlterByDropPrimaryKeyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByDropPrimaryKey(s) + } +} + +func (s *AlterByDropPrimaryKeyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByDropPrimaryKey(s) + } +} + +type AlterByLockContext struct { + AlterSpecificationContext + lockType antlr.Token +} + +func NewAlterByLockContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByLockContext { + var p = new(AlterByLockContext) + + InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSpecificationContext)) + + return p +} + +func (s *AlterByLockContext) GetLockType() antlr.Token { return s.lockType } + +func (s *AlterByLockContext) SetLockType(v antlr.Token) { s.lockType = v } + +func (s *AlterByLockContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByLockContext) LOCK() antlr.TerminalNode { + return s.GetToken(MySqlParserLOCK, 0) +} + +func (s *AlterByLockContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(MySqlParserDEFAULT, 0) +} + +func (s *AlterByLockContext) NONE() antlr.TerminalNode { + return s.GetToken(MySqlParserNONE, 0) +} + +func (s *AlterByLockContext) SHARED() antlr.TerminalNode { + return s.GetToken(MySqlParserSHARED, 0) +} + +func (s *AlterByLockContext) EXCLUSIVE() antlr.TerminalNode { + return s.GetToken(MySqlParserEXCLUSIVE, 0) +} + +func (s *AlterByLockContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *AlterByLockContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByLock(s) + } +} + +func (s *AlterByLockContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByLock(s) + } +} + +type AlterByDiscardTablespaceContext struct { + AlterSpecificationContext +} + +func NewAlterByDiscardTablespaceContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByDiscardTablespaceContext { + var p = new(AlterByDiscardTablespaceContext) + + InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSpecificationContext)) + + return p +} + +func (s *AlterByDiscardTablespaceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByDiscardTablespaceContext) DISCARD() antlr.TerminalNode { + return s.GetToken(MySqlParserDISCARD, 0) +} + +func (s *AlterByDiscardTablespaceContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLESPACE, 0) +} + +func (s *AlterByDiscardTablespaceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByDiscardTablespace(s) + } +} + +func (s *AlterByDiscardTablespaceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByDiscardTablespace(s) + } +} + +type AlterByValidateContext struct { + AlterSpecificationContext + validationFormat antlr.Token +} + +func NewAlterByValidateContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByValidateContext { + var p = new(AlterByValidateContext) + + InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSpecificationContext)) + + return p +} + +func (s *AlterByValidateContext) GetValidationFormat() antlr.Token { return s.validationFormat } + +func (s *AlterByValidateContext) SetValidationFormat(v antlr.Token) { s.validationFormat = v } + +func (s *AlterByValidateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByValidateContext) VALIDATION() antlr.TerminalNode { + return s.GetToken(MySqlParserVALIDATION, 0) +} + +func (s *AlterByValidateContext) WITHOUT() antlr.TerminalNode { + return s.GetToken(MySqlParserWITHOUT, 0) +} + +func (s *AlterByValidateContext) WITH() antlr.TerminalNode { + return s.GetToken(MySqlParserWITH, 0) +} + +func (s *AlterByValidateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByValidate(s) + } +} + +func (s *AlterByValidateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByValidate(s) + } +} + +type AlterByAddPrimaryKeyContext struct { + AlterSpecificationContext + name IUidContext + index IUidContext +} + +func NewAlterByAddPrimaryKeyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByAddPrimaryKeyContext { + var p = new(AlterByAddPrimaryKeyContext) + + InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSpecificationContext)) + + return p +} + +func (s *AlterByAddPrimaryKeyContext) GetName() IUidContext { return s.name } + +func (s *AlterByAddPrimaryKeyContext) GetIndex() IUidContext { return s.index } + +func (s *AlterByAddPrimaryKeyContext) SetName(v IUidContext) { s.name = v } + +func (s *AlterByAddPrimaryKeyContext) SetIndex(v IUidContext) { s.index = v } + +func (s *AlterByAddPrimaryKeyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByAddPrimaryKeyContext) ADD() antlr.TerminalNode { + return s.GetToken(MySqlParserADD, 0) +} + +func (s *AlterByAddPrimaryKeyContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(MySqlParserPRIMARY, 0) +} + +func (s *AlterByAddPrimaryKeyContext) KEY() antlr.TerminalNode { + return s.GetToken(MySqlParserKEY, 0) +} + +func (s *AlterByAddPrimaryKeyContext) IndexColumnNames() IIndexColumnNamesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexColumnNamesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndexColumnNamesContext) +} + +func (s *AlterByAddPrimaryKeyContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(MySqlParserCONSTRAINT, 0) +} + +func (s *AlterByAddPrimaryKeyContext) IndexType() IIndexTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndexTypeContext) +} + +func (s *AlterByAddPrimaryKeyContext) AllIndexOption() []IIndexOptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIndexOptionContext); ok { + len++ + } + } + + tst := make([]IIndexOptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIndexOptionContext); ok { + tst[i] = t.(IIndexOptionContext) + i++ + } + } + + return tst +} + +func (s *AlterByAddPrimaryKeyContext) IndexOption(i int) IIndexOptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexOptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIndexOptionContext) +} + +func (s *AlterByAddPrimaryKeyContext) AllUid() []IUidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUidContext); ok { + len++ + } + } + + tst := make([]IUidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUidContext); ok { + tst[i] = t.(IUidContext) + i++ + } + } + + return tst +} + +func (s *AlterByAddPrimaryKeyContext) Uid(i int) IUidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *AlterByAddPrimaryKeyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByAddPrimaryKey(s) + } +} + +func (s *AlterByAddPrimaryKeyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByAddPrimaryKey(s) + } +} + +type AlterByEnableKeysContext struct { + AlterSpecificationContext +} + +func NewAlterByEnableKeysContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByEnableKeysContext { + var p = new(AlterByEnableKeysContext) + + InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSpecificationContext)) + + return p +} + +func (s *AlterByEnableKeysContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByEnableKeysContext) ENABLE() antlr.TerminalNode { + return s.GetToken(MySqlParserENABLE, 0) +} + +func (s *AlterByEnableKeysContext) KEYS() antlr.TerminalNode { + return s.GetToken(MySqlParserKEYS, 0) +} + +func (s *AlterByEnableKeysContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByEnableKeys(s) + } +} + +func (s *AlterByEnableKeysContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByEnableKeys(s) + } +} + +type AlterBySetAlgorithmContext struct { + AlterSpecificationContext + algType antlr.Token +} + +func NewAlterBySetAlgorithmContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterBySetAlgorithmContext { + var p = new(AlterBySetAlgorithmContext) + + InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSpecificationContext)) + + return p +} + +func (s *AlterBySetAlgorithmContext) GetAlgType() antlr.Token { return s.algType } + +func (s *AlterBySetAlgorithmContext) SetAlgType(v antlr.Token) { s.algType = v } + +func (s *AlterBySetAlgorithmContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterBySetAlgorithmContext) ALGORITHM() antlr.TerminalNode { + return s.GetToken(MySqlParserALGORITHM, 0) +} + +func (s *AlterBySetAlgorithmContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(MySqlParserDEFAULT, 0) +} + +func (s *AlterBySetAlgorithmContext) INSTANT() antlr.TerminalNode { + return s.GetToken(MySqlParserINSTANT, 0) +} + +func (s *AlterBySetAlgorithmContext) INPLACE() antlr.TerminalNode { + return s.GetToken(MySqlParserINPLACE, 0) +} + +func (s *AlterBySetAlgorithmContext) COPY() antlr.TerminalNode { + return s.GetToken(MySqlParserCOPY, 0) +} + +func (s *AlterBySetAlgorithmContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *AlterBySetAlgorithmContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterBySetAlgorithm(s) + } +} + +func (s *AlterBySetAlgorithmContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterBySetAlgorithm(s) + } +} + +type AlterByChangeColumnContext struct { + AlterSpecificationContext + oldColumn IUidContext + newColumn IUidContext + afterColumn IUidContext +} + +func NewAlterByChangeColumnContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByChangeColumnContext { + var p = new(AlterByChangeColumnContext) + + InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSpecificationContext)) + + return p +} + +func (s *AlterByChangeColumnContext) GetOldColumn() IUidContext { return s.oldColumn } + +func (s *AlterByChangeColumnContext) GetNewColumn() IUidContext { return s.newColumn } + +func (s *AlterByChangeColumnContext) GetAfterColumn() IUidContext { return s.afterColumn } + +func (s *AlterByChangeColumnContext) SetOldColumn(v IUidContext) { s.oldColumn = v } + +func (s *AlterByChangeColumnContext) SetNewColumn(v IUidContext) { s.newColumn = v } + +func (s *AlterByChangeColumnContext) SetAfterColumn(v IUidContext) { s.afterColumn = v } + +func (s *AlterByChangeColumnContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByChangeColumnContext) CHANGE() antlr.TerminalNode { + return s.GetToken(MySqlParserCHANGE, 0) +} + +func (s *AlterByChangeColumnContext) ColumnDefinition() IColumnDefinitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnDefinitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnDefinitionContext) +} + +func (s *AlterByChangeColumnContext) AllUid() []IUidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUidContext); ok { + len++ + } + } + + tst := make([]IUidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUidContext); ok { + tst[i] = t.(IUidContext) + i++ + } + } + + return tst +} + +func (s *AlterByChangeColumnContext) Uid(i int) IUidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *AlterByChangeColumnContext) COLUMN() antlr.TerminalNode { + return s.GetToken(MySqlParserCOLUMN, 0) +} + +func (s *AlterByChangeColumnContext) FIRST() antlr.TerminalNode { + return s.GetToken(MySqlParserFIRST, 0) +} + +func (s *AlterByChangeColumnContext) AFTER() antlr.TerminalNode { + return s.GetToken(MySqlParserAFTER, 0) +} + +func (s *AlterByChangeColumnContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByChangeColumn(s) + } +} + +func (s *AlterByChangeColumnContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByChangeColumn(s) + } +} + +type AlterByAddUniqueKeyContext struct { + AlterSpecificationContext + name IUidContext + indexFormat antlr.Token + indexName IUidContext +} + +func NewAlterByAddUniqueKeyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByAddUniqueKeyContext { + var p = new(AlterByAddUniqueKeyContext) + + InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSpecificationContext)) + + return p +} + +func (s *AlterByAddUniqueKeyContext) GetIndexFormat() antlr.Token { return s.indexFormat } + +func (s *AlterByAddUniqueKeyContext) SetIndexFormat(v antlr.Token) { s.indexFormat = v } + +func (s *AlterByAddUniqueKeyContext) GetName() IUidContext { return s.name } + +func (s *AlterByAddUniqueKeyContext) GetIndexName() IUidContext { return s.indexName } + +func (s *AlterByAddUniqueKeyContext) SetName(v IUidContext) { s.name = v } + +func (s *AlterByAddUniqueKeyContext) SetIndexName(v IUidContext) { s.indexName = v } + +func (s *AlterByAddUniqueKeyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByAddUniqueKeyContext) ADD() antlr.TerminalNode { + return s.GetToken(MySqlParserADD, 0) +} + +func (s *AlterByAddUniqueKeyContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(MySqlParserUNIQUE, 0) +} + +func (s *AlterByAddUniqueKeyContext) IndexColumnNames() IIndexColumnNamesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexColumnNamesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndexColumnNamesContext) +} + +func (s *AlterByAddUniqueKeyContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(MySqlParserCONSTRAINT, 0) +} + +func (s *AlterByAddUniqueKeyContext) IndexType() IIndexTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndexTypeContext) +} + +func (s *AlterByAddUniqueKeyContext) AllIndexOption() []IIndexOptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIndexOptionContext); ok { + len++ + } + } + + tst := make([]IIndexOptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIndexOptionContext); ok { + tst[i] = t.(IIndexOptionContext) + i++ + } + } + + return tst +} + +func (s *AlterByAddUniqueKeyContext) IndexOption(i int) IIndexOptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexOptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIndexOptionContext) +} + +func (s *AlterByAddUniqueKeyContext) AllUid() []IUidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUidContext); ok { + len++ + } + } + + tst := make([]IUidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUidContext); ok { + tst[i] = t.(IUidContext) + i++ + } + } + + return tst +} + +func (s *AlterByAddUniqueKeyContext) Uid(i int) IUidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *AlterByAddUniqueKeyContext) INDEX() antlr.TerminalNode { + return s.GetToken(MySqlParserINDEX, 0) +} + +func (s *AlterByAddUniqueKeyContext) KEY() antlr.TerminalNode { + return s.GetToken(MySqlParserKEY, 0) +} + +func (s *AlterByAddUniqueKeyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByAddUniqueKey(s) + } +} + +func (s *AlterByAddUniqueKeyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByAddUniqueKey(s) + } +} + +type AlterByDropIndexContext struct { + AlterSpecificationContext + indexFormat antlr.Token +} + +func NewAlterByDropIndexContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByDropIndexContext { + var p = new(AlterByDropIndexContext) + + InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSpecificationContext)) + + return p +} + +func (s *AlterByDropIndexContext) GetIndexFormat() antlr.Token { return s.indexFormat } + +func (s *AlterByDropIndexContext) SetIndexFormat(v antlr.Token) { s.indexFormat = v } + +func (s *AlterByDropIndexContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByDropIndexContext) DROP() antlr.TerminalNode { + return s.GetToken(MySqlParserDROP, 0) +} + +func (s *AlterByDropIndexContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *AlterByDropIndexContext) INDEX() antlr.TerminalNode { + return s.GetToken(MySqlParserINDEX, 0) +} + +func (s *AlterByDropIndexContext) KEY() antlr.TerminalNode { + return s.GetToken(MySqlParserKEY, 0) +} + +func (s *AlterByDropIndexContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByDropIndex(s) + } +} + +func (s *AlterByDropIndexContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByDropIndex(s) + } +} + +type AlterByAddColumnContext struct { + AlterSpecificationContext +} + +func NewAlterByAddColumnContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByAddColumnContext { + var p = new(AlterByAddColumnContext) + + InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSpecificationContext)) + + return p +} + +func (s *AlterByAddColumnContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByAddColumnContext) ADD() antlr.TerminalNode { + return s.GetToken(MySqlParserADD, 0) +} + +func (s *AlterByAddColumnContext) AllUid() []IUidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUidContext); ok { + len++ + } + } + + tst := make([]IUidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUidContext); ok { + tst[i] = t.(IUidContext) + i++ + } + } + + return tst +} + +func (s *AlterByAddColumnContext) Uid(i int) IUidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *AlterByAddColumnContext) ColumnDefinition() IColumnDefinitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnDefinitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnDefinitionContext) +} + +func (s *AlterByAddColumnContext) COLUMN() antlr.TerminalNode { + return s.GetToken(MySqlParserCOLUMN, 0) +} + +func (s *AlterByAddColumnContext) FIRST() antlr.TerminalNode { + return s.GetToken(MySqlParserFIRST, 0) +} + +func (s *AlterByAddColumnContext) AFTER() antlr.TerminalNode { + return s.GetToken(MySqlParserAFTER, 0) +} + +func (s *AlterByAddColumnContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByAddColumn(s) + } +} + +func (s *AlterByAddColumnContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByAddColumn(s) + } +} + +type AlterByOrderContext struct { + AlterSpecificationContext +} + +func NewAlterByOrderContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByOrderContext { + var p = new(AlterByOrderContext) + + InitEmptyAlterSpecificationContext(&p.AlterSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSpecificationContext)) + + return p +} + +func (s *AlterByOrderContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByOrderContext) ORDER() antlr.TerminalNode { + return s.GetToken(MySqlParserORDER, 0) +} + +func (s *AlterByOrderContext) BY() antlr.TerminalNode { + return s.GetToken(MySqlParserBY, 0) +} + +func (s *AlterByOrderContext) UidList() IUidListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidListContext) +} + +func (s *AlterByOrderContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByOrder(s) + } +} + +func (s *AlterByOrderContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByOrder(s) + } +} + +func (p *MySqlParser) AlterSpecification() (localctx IAlterSpecificationContext) { + localctx = NewAlterSpecificationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 148, MySqlParserRULE_alterSpecification) + var _la int + + var _alt int + + p.SetState(2883) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 370, p.GetParserRuleContext()) { + case 1: + localctx = NewAlterByTableOptionContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2532) + p.TableOption() + } + p.SetState(2539) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 312, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(2534) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserCOMMA { + { + p.SetState(2533) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2536) + p.TableOption() + } + + } + p.SetState(2541) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 312, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 2: + localctx = NewAlterByAddColumnContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2542) + p.Match(MySqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2544) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserCOLUMN { + { + p.SetState(2543) + p.Match(MySqlParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2546) + p.Uid() + } + { + p.SetState(2547) + p.ColumnDefinition() + } + p.SetState(2551) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case MySqlParserFIRST: + { + p.SetState(2548) + p.Match(MySqlParserFIRST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserAFTER: + { + p.SetState(2549) + p.Match(MySqlParserAFTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2550) + p.Uid() + } + + case MySqlParserEOF, MySqlParserALTER, MySqlParserANALYZE, MySqlParserCALL, MySqlParserCHANGE, MySqlParserCHECK, MySqlParserCREATE, MySqlParserDELETE, MySqlParserDESC, MySqlParserDESCRIBE, MySqlParserDROP, MySqlParserEXPLAIN, MySqlParserGET, MySqlParserGRANT, MySqlParserINSERT, MySqlParserKILL, MySqlParserLOAD, MySqlParserLOCK, MySqlParserOPTIMIZE, MySqlParserPARTITION, MySqlParserPURGE, MySqlParserRELEASE, MySqlParserRENAME, MySqlParserREPLACE, MySqlParserRESIGNAL, MySqlParserREVOKE, MySqlParserSELECT, MySqlParserSET, MySqlParserSHOW, MySqlParserSIGNAL, MySqlParserTABLE, MySqlParserUNLOCK, MySqlParserUPDATE, MySqlParserUSE, MySqlParserVALUES, MySqlParserWITH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserCACHE, MySqlParserCHECKSUM, MySqlParserCOMMIT, MySqlParserDEALLOCATE, MySqlParserDO, MySqlParserFLUSH, MySqlParserHANDLER, MySqlParserHELP, MySqlParserINSTALL, MySqlParserPREPARE, MySqlParserREPAIR, MySqlParserRESET, MySqlParserROLLBACK, MySqlParserSAVEPOINT, MySqlParserSTART, MySqlParserSTOP, MySqlParserTRUNCATE, MySqlParserUNINSTALL, MySqlParserXA, MySqlParserEXECUTE, MySqlParserSHUTDOWN, MySqlParserMINUS, MySqlParserLR_BRACKET, MySqlParserCOMMA, MySqlParserSEMI: + + default: + } + + case 3: + localctx = NewAlterByAddColumnsContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2553) + p.Match(MySqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2555) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserCOLUMN { + { + p.SetState(2554) + p.Match(MySqlParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2557) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2558) + p.Uid() + } + { + p.SetState(2559) + p.ColumnDefinition() + } + p.SetState(2566) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(2560) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2561) + p.Uid() + } + { + p.SetState(2562) + p.ColumnDefinition() + } + + p.SetState(2568) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2569) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + localctx = NewAlterByAddIndexContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(2571) + p.Match(MySqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2572) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*AlterByAddIndexContext).indexFormat = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserINDEX || _la == MySqlParserKEY) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*AlterByAddIndexContext).indexFormat = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(2574) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-34354363873) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-2199023255553) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-5764611921080745985) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-8796126576641) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-32651097298436097) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-18014398517872129) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-137438953601) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-44473063500156929) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-129) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-12289) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&-1) != 0) || ((int64((_la-1128)) & ^0x3f) == 0 && ((int64(1)<<(_la-1128))&8627683329) != 0) { + { + p.SetState(2573) + p.Uid() + } + + } + p.SetState(2577) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserUSING { + { + p.SetState(2576) + p.IndexType() + } + + } + { + p.SetState(2579) + p.IndexColumnNames() + } + p.SetState(2583) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 319, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2580) + p.IndexOption() + } + + } + p.SetState(2585) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 319, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 5: + localctx = NewAlterByAddPrimaryKeyContext(p, localctx) + p.EnterOuterAlt(localctx, 5) + { + p.SetState(2586) + p.Match(MySqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2591) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserCONSTRAINT { + { + p.SetState(2587) + p.Match(MySqlParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2589) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 320, p.GetParserRuleContext()) == 1 { + { + p.SetState(2588) + + var _x = p.Uid() + + localctx.(*AlterByAddPrimaryKeyContext).name = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } + { + p.SetState(2593) + p.Match(MySqlParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2594) + p.Match(MySqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2596) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-34354363873) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-2199023255553) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-5764611921080745985) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-8796126576641) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-32651097298436097) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-18014398517872129) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-137438953601) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-44473063500156929) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-129) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-12289) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&-1) != 0) || ((int64((_la-1128)) & ^0x3f) == 0 && ((int64(1)<<(_la-1128))&8627683329) != 0) { + { + p.SetState(2595) + + var _x = p.Uid() + + localctx.(*AlterByAddPrimaryKeyContext).index = _x + } + + } + p.SetState(2599) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserUSING { + { + p.SetState(2598) + p.IndexType() + } + + } + { + p.SetState(2601) + p.IndexColumnNames() + } + p.SetState(2605) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 324, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2602) + p.IndexOption() + } + + } + p.SetState(2607) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 324, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 6: + localctx = NewAlterByAddUniqueKeyContext(p, localctx) + p.EnterOuterAlt(localctx, 6) + { + p.SetState(2608) + p.Match(MySqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2613) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserCONSTRAINT { + { + p.SetState(2609) + p.Match(MySqlParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2611) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-34354363873) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-2199023255553) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-5764611921080745985) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-8796126576641) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-32651097298436097) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-18014398517872129) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-137438953601) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-44473063500156929) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-129) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-12289) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&-1) != 0) || ((int64((_la-1128)) & ^0x3f) == 0 && ((int64(1)<<(_la-1128))&8627683329) != 0) { + { + p.SetState(2610) + + var _x = p.Uid() + + localctx.(*AlterByAddUniqueKeyContext).name = _x + } + + } + + } + { + p.SetState(2615) + p.Match(MySqlParserUNIQUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2617) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserINDEX || _la == MySqlParserKEY { + { + p.SetState(2616) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*AlterByAddUniqueKeyContext).indexFormat = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserINDEX || _la == MySqlParserKEY) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*AlterByAddUniqueKeyContext).indexFormat = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(2620) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-34354363873) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-2199023255553) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-5764611921080745985) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-8796126576641) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-32651097298436097) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-18014398517872129) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-137438953601) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-44473063500156929) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-129) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-12289) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&-1) != 0) || ((int64((_la-1128)) & ^0x3f) == 0 && ((int64(1)<<(_la-1128))&8627683329) != 0) { + { + p.SetState(2619) + + var _x = p.Uid() + + localctx.(*AlterByAddUniqueKeyContext).indexName = _x + } + + } + p.SetState(2623) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserUSING { + { + p.SetState(2622) + p.IndexType() + } + + } + { + p.SetState(2625) + p.IndexColumnNames() + } + p.SetState(2629) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 330, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2626) + p.IndexOption() + } + + } + p.SetState(2631) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 330, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 7: + localctx = NewAlterByAddSpecialIndexContext(p, localctx) + p.EnterOuterAlt(localctx, 7) + { + p.SetState(2632) + p.Match(MySqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2633) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*AlterByAddSpecialIndexContext).keyType = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserFULLTEXT || _la == MySqlParserSPATIAL) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*AlterByAddSpecialIndexContext).keyType = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(2635) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserINDEX || _la == MySqlParserKEY { + { + p.SetState(2634) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*AlterByAddSpecialIndexContext).indexFormat = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserINDEX || _la == MySqlParserKEY) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*AlterByAddSpecialIndexContext).indexFormat = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(2638) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-34354363873) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-2199023255553) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-5764611921080745985) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-8796126576641) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-32651097298436097) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-18014398517872129) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-137438953601) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-44473063500156929) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-129) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-12289) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&-1) != 0) || ((int64((_la-1128)) & ^0x3f) == 0 && ((int64(1)<<(_la-1128))&8627683329) != 0) { + { + p.SetState(2637) + p.Uid() + } + + } + { + p.SetState(2640) + p.IndexColumnNames() + } + p.SetState(2644) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 333, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2641) + p.IndexOption() + } + + } + p.SetState(2646) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 333, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 8: + localctx = NewAlterByAddForeignKeyContext(p, localctx) + p.EnterOuterAlt(localctx, 8) + { + p.SetState(2647) + p.Match(MySqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2652) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserCONSTRAINT { + { + p.SetState(2648) + p.Match(MySqlParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2650) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-34354363873) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-2199023255553) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-5764611921080745985) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-8796126576641) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-32651097298436097) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-18014398517872129) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-137438953601) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-44473063500156929) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-129) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-12289) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&-1) != 0) || ((int64((_la-1128)) & ^0x3f) == 0 && ((int64(1)<<(_la-1128))&8627683329) != 0) { + { + p.SetState(2649) + + var _x = p.Uid() + + localctx.(*AlterByAddForeignKeyContext).name = _x + } + + } + + } + { + p.SetState(2654) + p.Match(MySqlParserFOREIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2655) + p.Match(MySqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2657) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-34354363873) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-2199023255553) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-5764611921080745985) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-8796126576641) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-32651097298436097) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-18014398517872129) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-137438953601) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-44473063500156929) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-129) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-12289) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&-1) != 0) || ((int64((_la-1128)) & ^0x3f) == 0 && ((int64(1)<<(_la-1128))&8627683329) != 0) { + { + p.SetState(2656) + + var _x = p.Uid() + + localctx.(*AlterByAddForeignKeyContext).indexName = _x + } + + } + { + p.SetState(2659) + p.IndexColumnNames() + } + { + p.SetState(2660) + p.ReferenceDefinition() + } + + case 9: + localctx = NewAlterByAddCheckTableConstraintContext(p, localctx) + p.EnterOuterAlt(localctx, 9) + { + p.SetState(2662) + p.Match(MySqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2667) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserCONSTRAINT { + { + p.SetState(2663) + p.Match(MySqlParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2665) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-34354363873) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-2199023255553) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-5764611921080745985) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-8796126576641) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-32651097298436097) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-18014398517872129) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-137438953601) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-44473063500156929) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-129) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-12289) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&-1) != 0) || ((int64((_la-1128)) & ^0x3f) == 0 && ((int64(1)<<(_la-1128))&8627683329) != 0) { + { + p.SetState(2664) + + var _x = p.Uid() + + localctx.(*AlterByAddCheckTableConstraintContext).name = _x + } + + } + + } + { + p.SetState(2669) + p.Match(MySqlParserCHECK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2676) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 339, p.GetParserRuleContext()) { + case 1: + { + p.SetState(2670) + p.Uid() + } + + case 2: + { + p.SetState(2671) + p.StringLiteral() + } + + case 3: + { + p.SetState(2672) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2673) + p.expression(0) + } + { + p.SetState(2674) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(2679) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserNOT { + { + p.SetState(2678) + p.Match(MySqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(2682) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserENFORCED { + { + p.SetState(2681) + p.Match(MySqlParserENFORCED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 10: + localctx = NewAlterByAlterCheckTableConstraintContext(p, localctx) + p.EnterOuterAlt(localctx, 10) + { + p.SetState(2684) + p.Match(MySqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2689) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserCONSTRAINT { + { + p.SetState(2685) + p.Match(MySqlParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2687) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-34354363873) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-2199023255553) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-5764611921080745985) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-8796126576641) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-32651097298436097) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-18014398517872129) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-137438953601) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-44473063500156929) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-129) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-12289) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&-1) != 0) || ((int64((_la-1128)) & ^0x3f) == 0 && ((int64(1)<<(_la-1128))&8627683329) != 0) { + { + p.SetState(2686) + + var _x = p.Uid() + + localctx.(*AlterByAlterCheckTableConstraintContext).name = _x + } + + } + + } + { + p.SetState(2691) + p.Match(MySqlParserCHECK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2698) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 344, p.GetParserRuleContext()) { + case 1: + { + p.SetState(2692) + p.Uid() + } + + case 2: + { + p.SetState(2693) + p.StringLiteral() + } + + case 3: + { + p.SetState(2694) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2695) + p.expression(0) + } + { + p.SetState(2696) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(2701) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserNOT { + { + p.SetState(2700) + p.Match(MySqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(2704) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserENFORCED { + { + p.SetState(2703) + p.Match(MySqlParserENFORCED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 11: + localctx = NewAlterByAddCheckTableConstraintContext(p, localctx) + p.EnterOuterAlt(localctx, 11) + { + p.SetState(2706) + p.Match(MySqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2711) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserCONSTRAINT { + { + p.SetState(2707) + p.Match(MySqlParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2709) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-34354363873) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-2199023255553) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-5764611921080745985) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-8796126576641) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-32651097298436097) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-18014398517872129) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-137438953601) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-44473063500156929) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-129) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-12289) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&-1) != 0) || ((int64((_la-1128)) & ^0x3f) == 0 && ((int64(1)<<(_la-1128))&8627683329) != 0) { + { + p.SetState(2708) + + var _x = p.Uid() + + localctx.(*AlterByAddCheckTableConstraintContext).name = _x + } + + } + + } + { + p.SetState(2713) + p.Match(MySqlParserCHECK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2714) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2715) + p.expression(0) + } + { + p.SetState(2716) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 12: + localctx = NewAlterBySetAlgorithmContext(p, localctx) + p.EnterOuterAlt(localctx, 12) + { + p.SetState(2718) + p.Match(MySqlParserALGORITHM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2720) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(2719) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2722) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*AlterBySetAlgorithmContext).algType = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserDEFAULT || _la == MySqlParserCOPY || _la == MySqlParserINPLACE || _la == MySqlParserINSTANT) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*AlterBySetAlgorithmContext).algType = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 13: + localctx = NewAlterByChangeDefaultContext(p, localctx) + p.EnterOuterAlt(localctx, 13) + { + p.SetState(2723) + p.Match(MySqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2725) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserCOLUMN { + { + p.SetState(2724) + p.Match(MySqlParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2727) + p.Uid() + } + p.SetState(2733) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserSET: + { + p.SetState(2728) + p.Match(MySqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2729) + p.Match(MySqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2730) + p.DefaultValue() + } + + case MySqlParserDROP: + { + p.SetState(2731) + p.Match(MySqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2732) + p.Match(MySqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 14: + localctx = NewAlterByChangeColumnContext(p, localctx) + p.EnterOuterAlt(localctx, 14) + { + p.SetState(2735) + p.Match(MySqlParserCHANGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2737) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserCOLUMN { + { + p.SetState(2736) + p.Match(MySqlParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2739) + + var _x = p.Uid() + + localctx.(*AlterByChangeColumnContext).oldColumn = _x + } + { + p.SetState(2740) + + var _x = p.Uid() + + localctx.(*AlterByChangeColumnContext).newColumn = _x + } + { + p.SetState(2741) + p.ColumnDefinition() + } + p.SetState(2745) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case MySqlParserFIRST: + { + p.SetState(2742) + p.Match(MySqlParserFIRST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserAFTER: + { + p.SetState(2743) + p.Match(MySqlParserAFTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2744) + + var _x = p.Uid() + + localctx.(*AlterByChangeColumnContext).afterColumn = _x + } + + case MySqlParserEOF, MySqlParserALTER, MySqlParserANALYZE, MySqlParserCALL, MySqlParserCHANGE, MySqlParserCHECK, MySqlParserCREATE, MySqlParserDELETE, MySqlParserDESC, MySqlParserDESCRIBE, MySqlParserDROP, MySqlParserEXPLAIN, MySqlParserGET, MySqlParserGRANT, MySqlParserINSERT, MySqlParserKILL, MySqlParserLOAD, MySqlParserLOCK, MySqlParserOPTIMIZE, MySqlParserPARTITION, MySqlParserPURGE, MySqlParserRELEASE, MySqlParserRENAME, MySqlParserREPLACE, MySqlParserRESIGNAL, MySqlParserREVOKE, MySqlParserSELECT, MySqlParserSET, MySqlParserSHOW, MySqlParserSIGNAL, MySqlParserTABLE, MySqlParserUNLOCK, MySqlParserUPDATE, MySqlParserUSE, MySqlParserVALUES, MySqlParserWITH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserCACHE, MySqlParserCHECKSUM, MySqlParserCOMMIT, MySqlParserDEALLOCATE, MySqlParserDO, MySqlParserFLUSH, MySqlParserHANDLER, MySqlParserHELP, MySqlParserINSTALL, MySqlParserPREPARE, MySqlParserREPAIR, MySqlParserRESET, MySqlParserROLLBACK, MySqlParserSAVEPOINT, MySqlParserSTART, MySqlParserSTOP, MySqlParserTRUNCATE, MySqlParserUNINSTALL, MySqlParserXA, MySqlParserEXECUTE, MySqlParserSHUTDOWN, MySqlParserMINUS, MySqlParserLR_BRACKET, MySqlParserCOMMA, MySqlParserSEMI: + + default: + } + + case 15: + localctx = NewAlterByRenameColumnContext(p, localctx) + p.EnterOuterAlt(localctx, 15) + { + p.SetState(2747) + p.Match(MySqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2748) + p.Match(MySqlParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2749) + + var _x = p.Uid() + + localctx.(*AlterByRenameColumnContext).oldColumn = _x + } + { + p.SetState(2750) + p.Match(MySqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2751) + + var _x = p.Uid() + + localctx.(*AlterByRenameColumnContext).newColumn = _x + } + + case 16: + localctx = NewAlterByLockContext(p, localctx) + p.EnterOuterAlt(localctx, 16) + { + p.SetState(2753) + p.Match(MySqlParserLOCK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2755) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(2754) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2757) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*AlterByLockContext).lockType = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserDEFAULT || _la == MySqlParserEXCLUSIVE || _la == MySqlParserNONE || _la == MySqlParserSHARED) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*AlterByLockContext).lockType = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 17: + localctx = NewAlterByModifyColumnContext(p, localctx) + p.EnterOuterAlt(localctx, 17) + { + p.SetState(2758) + p.Match(MySqlParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2760) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserCOLUMN { + { + p.SetState(2759) + p.Match(MySqlParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2762) + p.Uid() + } + { + p.SetState(2763) + p.ColumnDefinition() + } + p.SetState(2767) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case MySqlParserFIRST: + { + p.SetState(2764) + p.Match(MySqlParserFIRST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserAFTER: + { + p.SetState(2765) + p.Match(MySqlParserAFTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2766) + p.Uid() + } + + case MySqlParserEOF, MySqlParserALTER, MySqlParserANALYZE, MySqlParserCALL, MySqlParserCHANGE, MySqlParserCHECK, MySqlParserCREATE, MySqlParserDELETE, MySqlParserDESC, MySqlParserDESCRIBE, MySqlParserDROP, MySqlParserEXPLAIN, MySqlParserGET, MySqlParserGRANT, MySqlParserINSERT, MySqlParserKILL, MySqlParserLOAD, MySqlParserLOCK, MySqlParserOPTIMIZE, MySqlParserPARTITION, MySqlParserPURGE, MySqlParserRELEASE, MySqlParserRENAME, MySqlParserREPLACE, MySqlParserRESIGNAL, MySqlParserREVOKE, MySqlParserSELECT, MySqlParserSET, MySqlParserSHOW, MySqlParserSIGNAL, MySqlParserTABLE, MySqlParserUNLOCK, MySqlParserUPDATE, MySqlParserUSE, MySqlParserVALUES, MySqlParserWITH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserCACHE, MySqlParserCHECKSUM, MySqlParserCOMMIT, MySqlParserDEALLOCATE, MySqlParserDO, MySqlParserFLUSH, MySqlParserHANDLER, MySqlParserHELP, MySqlParserINSTALL, MySqlParserPREPARE, MySqlParserREPAIR, MySqlParserRESET, MySqlParserROLLBACK, MySqlParserSAVEPOINT, MySqlParserSTART, MySqlParserSTOP, MySqlParserTRUNCATE, MySqlParserUNINSTALL, MySqlParserXA, MySqlParserEXECUTE, MySqlParserSHUTDOWN, MySqlParserMINUS, MySqlParserLR_BRACKET, MySqlParserCOMMA, MySqlParserSEMI: + + default: + } + + case 18: + localctx = NewAlterByDropColumnContext(p, localctx) + p.EnterOuterAlt(localctx, 18) + { + p.SetState(2769) + p.Match(MySqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2771) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserCOLUMN { + { + p.SetState(2770) + p.Match(MySqlParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2773) + p.Uid() + } + p.SetState(2775) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserRESTRICT { + { + p.SetState(2774) + p.Match(MySqlParserRESTRICT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 19: + localctx = NewAlterByDropConstraintCheckContext(p, localctx) + p.EnterOuterAlt(localctx, 19) + { + p.SetState(2777) + p.Match(MySqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2778) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserCHECK || _la == MySqlParserCONSTRAINT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2779) + p.Uid() + } + + case 20: + localctx = NewAlterByDropPrimaryKeyContext(p, localctx) + p.EnterOuterAlt(localctx, 20) + { + p.SetState(2780) + p.Match(MySqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2781) + p.Match(MySqlParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2782) + p.Match(MySqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 21: + localctx = NewAlterByDropIndexContext(p, localctx) + p.EnterOuterAlt(localctx, 21) + { + p.SetState(2783) + p.Match(MySqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2784) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*AlterByDropIndexContext).indexFormat = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserINDEX || _la == MySqlParserKEY) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*AlterByDropIndexContext).indexFormat = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2785) + p.Uid() + } + + case 22: + localctx = NewAlterByRenameIndexContext(p, localctx) + p.EnterOuterAlt(localctx, 22) + { + p.SetState(2786) + p.Match(MySqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2787) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*AlterByRenameIndexContext).indexFormat = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserINDEX || _la == MySqlParserKEY) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*AlterByRenameIndexContext).indexFormat = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2788) + p.Uid() + } + { + p.SetState(2789) + p.Match(MySqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2790) + p.Uid() + } + + case 23: + localctx = NewAlterByAlterColumnDefaultContext(p, localctx) + p.EnterOuterAlt(localctx, 23) + { + p.SetState(2792) + p.Match(MySqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2794) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserCOLUMN { + { + p.SetState(2793) + p.Match(MySqlParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2796) + p.Uid() + } + p.SetState(2810) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 361, p.GetParserRuleContext()) { + case 1: + { + p.SetState(2797) + p.Match(MySqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2798) + p.Match(MySqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2804) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserSTART_NATIONAL_STRING_LITERAL, MySqlParserSTRING_LITERAL, MySqlParserSTRING_CHARSET_NAME: + { + p.SetState(2799) + p.StringLiteral() + } + + case MySqlParserLR_BRACKET: + { + p.SetState(2800) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2801) + p.expression(0) + } + { + p.SetState(2802) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 2: + { + p.SetState(2806) + p.Match(MySqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2807) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserINVISIBLE || _la == MySqlParserVISIBLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 3: + { + p.SetState(2808) + p.Match(MySqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2809) + p.Match(MySqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case 24: + localctx = NewAlterByAlterIndexVisibilityContext(p, localctx) + p.EnterOuterAlt(localctx, 24) + { + p.SetState(2812) + p.Match(MySqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2813) + p.Match(MySqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2814) + p.Uid() + } + { + p.SetState(2815) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserINVISIBLE || _la == MySqlParserVISIBLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 25: + localctx = NewAlterByDropForeignKeyContext(p, localctx) + p.EnterOuterAlt(localctx, 25) + { + p.SetState(2817) + p.Match(MySqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2818) + p.Match(MySqlParserFOREIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2819) + p.Match(MySqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2820) + p.Uid() + } + + case 26: + localctx = NewAlterByDisableKeysContext(p, localctx) + p.EnterOuterAlt(localctx, 26) + { + p.SetState(2821) + p.Match(MySqlParserDISABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2822) + p.Match(MySqlParserKEYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 27: + localctx = NewAlterByEnableKeysContext(p, localctx) + p.EnterOuterAlt(localctx, 27) + { + p.SetState(2823) + p.Match(MySqlParserENABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2824) + p.Match(MySqlParserKEYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 28: + localctx = NewAlterByRenameContext(p, localctx) + p.EnterOuterAlt(localctx, 28) + { + p.SetState(2825) + p.Match(MySqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2827) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserAS || _la == MySqlParserTO { + { + p.SetState(2826) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*AlterByRenameContext).renameFormat = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserAS || _la == MySqlParserTO) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*AlterByRenameContext).renameFormat = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(2831) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 363, p.GetParserRuleContext()) { + case 1: + { + p.SetState(2829) + p.Uid() + } + + case 2: + { + p.SetState(2830) + p.FullId() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case 29: + localctx = NewAlterByOrderContext(p, localctx) + p.EnterOuterAlt(localctx, 29) + { + p.SetState(2833) + p.Match(MySqlParserORDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2834) + p.Match(MySqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2835) + p.UidList() + } + + case 30: + localctx = NewAlterByConvertCharsetContext(p, localctx) + p.EnterOuterAlt(localctx, 30) + { + p.SetState(2836) + p.Match(MySqlParserCONVERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2837) + p.Match(MySqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2841) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserCHARSET: + { + p.SetState(2838) + p.Match(MySqlParserCHARSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserCHARACTER: + { + p.SetState(2839) + p.Match(MySqlParserCHARACTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2840) + p.Match(MySqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(2843) + p.CharsetName() + } + p.SetState(2846) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserCOLLATE { + { + p.SetState(2844) + p.Match(MySqlParserCOLLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2845) + p.CollationName() + } + + } + + case 31: + localctx = NewAlterByDefaultCharsetContext(p, localctx) + p.EnterOuterAlt(localctx, 31) + p.SetState(2849) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserDEFAULT { + { + p.SetState(2848) + p.Match(MySqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2851) + p.Match(MySqlParserCHARACTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2852) + p.Match(MySqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2853) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2854) + p.CharsetName() + } + p.SetState(2858) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserCOLLATE { + { + p.SetState(2855) + p.Match(MySqlParserCOLLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2856) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2857) + p.CollationName() + } + + } + + case 32: + localctx = NewAlterByDiscardTablespaceContext(p, localctx) + p.EnterOuterAlt(localctx, 32) + { + p.SetState(2860) + p.Match(MySqlParserDISCARD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2861) + p.Match(MySqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 33: + localctx = NewAlterByImportTablespaceContext(p, localctx) + p.EnterOuterAlt(localctx, 33) + { + p.SetState(2862) + p.Match(MySqlParserIMPORT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2863) + p.Match(MySqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 34: + localctx = NewAlterByForceContext(p, localctx) + p.EnterOuterAlt(localctx, 34) + { + p.SetState(2864) + p.Match(MySqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 35: + localctx = NewAlterByValidateContext(p, localctx) + p.EnterOuterAlt(localctx, 35) + { + p.SetState(2865) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*AlterByValidateContext).validationFormat = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserWITH || _la == MySqlParserWITHOUT) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*AlterByValidateContext).validationFormat = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2866) + p.Match(MySqlParserVALIDATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 36: + localctx = NewAlterByAddDefinitionsContext(p, localctx) + p.EnterOuterAlt(localctx, 36) + { + p.SetState(2867) + p.Match(MySqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2869) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserCOLUMN { + { + p.SetState(2868) + p.Match(MySqlParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2871) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2872) + p.CreateDefinition() + } + p.SetState(2877) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(2873) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2874) + p.CreateDefinition() + } + + p.SetState(2879) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2880) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 37: + localctx = NewAlterPartitionContext(p, localctx) + p.EnterOuterAlt(localctx, 37) + { + p.SetState(2882) + p.AlterPartitionSpecification() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterPartitionSpecificationContext is an interface to support dynamic dispatch. +type IAlterPartitionSpecificationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsAlterPartitionSpecificationContext differentiates from other interfaces. + IsAlterPartitionSpecificationContext() +} + +type AlterPartitionSpecificationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterPartitionSpecificationContext() *AlterPartitionSpecificationContext { + var p = new(AlterPartitionSpecificationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_alterPartitionSpecification + return p +} + +func InitEmptyAlterPartitionSpecificationContext(p *AlterPartitionSpecificationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_alterPartitionSpecification +} + +func (*AlterPartitionSpecificationContext) IsAlterPartitionSpecificationContext() {} + +func NewAlterPartitionSpecificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterPartitionSpecificationContext { + var p = new(AlterPartitionSpecificationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_alterPartitionSpecification + + return p +} + +func (s *AlterPartitionSpecificationContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterPartitionSpecificationContext) CopyAll(ctx *AlterPartitionSpecificationContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *AlterPartitionSpecificationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterPartitionSpecificationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type AlterByImportPartitionContext struct { + AlterPartitionSpecificationContext +} + +func NewAlterByImportPartitionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByImportPartitionContext { + var p = new(AlterByImportPartitionContext) + + InitEmptyAlterPartitionSpecificationContext(&p.AlterPartitionSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterPartitionSpecificationContext)) + + return p +} + +func (s *AlterByImportPartitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByImportPartitionContext) IMPORT() antlr.TerminalNode { + return s.GetToken(MySqlParserIMPORT, 0) +} + +func (s *AlterByImportPartitionContext) PARTITION() antlr.TerminalNode { + return s.GetToken(MySqlParserPARTITION, 0) +} + +func (s *AlterByImportPartitionContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLESPACE, 0) +} + +func (s *AlterByImportPartitionContext) UidList() IUidListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidListContext) +} + +func (s *AlterByImportPartitionContext) ALL() antlr.TerminalNode { + return s.GetToken(MySqlParserALL, 0) +} + +func (s *AlterByImportPartitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByImportPartition(s) + } +} + +func (s *AlterByImportPartitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByImportPartition(s) + } +} + +type AlterByDropPartitionContext struct { + AlterPartitionSpecificationContext +} + +func NewAlterByDropPartitionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByDropPartitionContext { + var p = new(AlterByDropPartitionContext) + + InitEmptyAlterPartitionSpecificationContext(&p.AlterPartitionSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterPartitionSpecificationContext)) + + return p +} + +func (s *AlterByDropPartitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByDropPartitionContext) DROP() antlr.TerminalNode { + return s.GetToken(MySqlParserDROP, 0) +} + +func (s *AlterByDropPartitionContext) PARTITION() antlr.TerminalNode { + return s.GetToken(MySqlParserPARTITION, 0) +} + +func (s *AlterByDropPartitionContext) UidList() IUidListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidListContext) +} + +func (s *AlterByDropPartitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByDropPartition(s) + } +} + +func (s *AlterByDropPartitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByDropPartition(s) + } +} + +type AlterByDiscardPartitionContext struct { + AlterPartitionSpecificationContext +} + +func NewAlterByDiscardPartitionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByDiscardPartitionContext { + var p = new(AlterByDiscardPartitionContext) + + InitEmptyAlterPartitionSpecificationContext(&p.AlterPartitionSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterPartitionSpecificationContext)) + + return p +} + +func (s *AlterByDiscardPartitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByDiscardPartitionContext) DISCARD() antlr.TerminalNode { + return s.GetToken(MySqlParserDISCARD, 0) +} + +func (s *AlterByDiscardPartitionContext) PARTITION() antlr.TerminalNode { + return s.GetToken(MySqlParserPARTITION, 0) +} + +func (s *AlterByDiscardPartitionContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLESPACE, 0) +} + +func (s *AlterByDiscardPartitionContext) UidList() IUidListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidListContext) +} + +func (s *AlterByDiscardPartitionContext) ALL() antlr.TerminalNode { + return s.GetToken(MySqlParserALL, 0) +} + +func (s *AlterByDiscardPartitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByDiscardPartition(s) + } +} + +func (s *AlterByDiscardPartitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByDiscardPartition(s) + } +} + +type AlterByAddPartitionContext struct { + AlterPartitionSpecificationContext +} + +func NewAlterByAddPartitionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByAddPartitionContext { + var p = new(AlterByAddPartitionContext) + + InitEmptyAlterPartitionSpecificationContext(&p.AlterPartitionSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterPartitionSpecificationContext)) + + return p +} + +func (s *AlterByAddPartitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByAddPartitionContext) ADD() antlr.TerminalNode { + return s.GetToken(MySqlParserADD, 0) +} + +func (s *AlterByAddPartitionContext) PARTITION() antlr.TerminalNode { + return s.GetToken(MySqlParserPARTITION, 0) +} + +func (s *AlterByAddPartitionContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *AlterByAddPartitionContext) AllPartitionDefinition() []IPartitionDefinitionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPartitionDefinitionContext); ok { + len++ + } + } + + tst := make([]IPartitionDefinitionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPartitionDefinitionContext); ok { + tst[i] = t.(IPartitionDefinitionContext) + i++ + } + } + + return tst +} + +func (s *AlterByAddPartitionContext) PartitionDefinition(i int) IPartitionDefinitionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionDefinitionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPartitionDefinitionContext) +} + +func (s *AlterByAddPartitionContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *AlterByAddPartitionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *AlterByAddPartitionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *AlterByAddPartitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByAddPartition(s) + } +} + +func (s *AlterByAddPartitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByAddPartition(s) + } +} + +type AlterByRemovePartitioningContext struct { + AlterPartitionSpecificationContext +} + +func NewAlterByRemovePartitioningContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByRemovePartitioningContext { + var p = new(AlterByRemovePartitioningContext) + + InitEmptyAlterPartitionSpecificationContext(&p.AlterPartitionSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterPartitionSpecificationContext)) + + return p +} + +func (s *AlterByRemovePartitioningContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByRemovePartitioningContext) REMOVE() antlr.TerminalNode { + return s.GetToken(MySqlParserREMOVE, 0) +} + +func (s *AlterByRemovePartitioningContext) PARTITIONING() antlr.TerminalNode { + return s.GetToken(MySqlParserPARTITIONING, 0) +} + +func (s *AlterByRemovePartitioningContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByRemovePartitioning(s) + } +} + +func (s *AlterByRemovePartitioningContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByRemovePartitioning(s) + } +} + +type AlterByOptimizePartitionContext struct { + AlterPartitionSpecificationContext +} + +func NewAlterByOptimizePartitionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByOptimizePartitionContext { + var p = new(AlterByOptimizePartitionContext) + + InitEmptyAlterPartitionSpecificationContext(&p.AlterPartitionSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterPartitionSpecificationContext)) + + return p +} + +func (s *AlterByOptimizePartitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByOptimizePartitionContext) OPTIMIZE() antlr.TerminalNode { + return s.GetToken(MySqlParserOPTIMIZE, 0) +} + +func (s *AlterByOptimizePartitionContext) PARTITION() antlr.TerminalNode { + return s.GetToken(MySqlParserPARTITION, 0) +} + +func (s *AlterByOptimizePartitionContext) UidList() IUidListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidListContext) +} + +func (s *AlterByOptimizePartitionContext) ALL() antlr.TerminalNode { + return s.GetToken(MySqlParserALL, 0) +} + +func (s *AlterByOptimizePartitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByOptimizePartition(s) + } +} + +func (s *AlterByOptimizePartitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByOptimizePartition(s) + } +} + +type AlterByCheckPartitionContext struct { + AlterPartitionSpecificationContext +} + +func NewAlterByCheckPartitionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByCheckPartitionContext { + var p = new(AlterByCheckPartitionContext) + + InitEmptyAlterPartitionSpecificationContext(&p.AlterPartitionSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterPartitionSpecificationContext)) + + return p +} + +func (s *AlterByCheckPartitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByCheckPartitionContext) CHECK() antlr.TerminalNode { + return s.GetToken(MySqlParserCHECK, 0) +} + +func (s *AlterByCheckPartitionContext) PARTITION() antlr.TerminalNode { + return s.GetToken(MySqlParserPARTITION, 0) +} + +func (s *AlterByCheckPartitionContext) UidList() IUidListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidListContext) +} + +func (s *AlterByCheckPartitionContext) ALL() antlr.TerminalNode { + return s.GetToken(MySqlParserALL, 0) +} + +func (s *AlterByCheckPartitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByCheckPartition(s) + } +} + +func (s *AlterByCheckPartitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByCheckPartition(s) + } +} + +type AlterByCoalescePartitionContext struct { + AlterPartitionSpecificationContext +} + +func NewAlterByCoalescePartitionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByCoalescePartitionContext { + var p = new(AlterByCoalescePartitionContext) + + InitEmptyAlterPartitionSpecificationContext(&p.AlterPartitionSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterPartitionSpecificationContext)) + + return p +} + +func (s *AlterByCoalescePartitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByCoalescePartitionContext) COALESCE() antlr.TerminalNode { + return s.GetToken(MySqlParserCOALESCE, 0) +} + +func (s *AlterByCoalescePartitionContext) PARTITION() antlr.TerminalNode { + return s.GetToken(MySqlParserPARTITION, 0) +} + +func (s *AlterByCoalescePartitionContext) DecimalLiteral() IDecimalLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *AlterByCoalescePartitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByCoalescePartition(s) + } +} + +func (s *AlterByCoalescePartitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByCoalescePartition(s) + } +} + +type AlterByReorganizePartitionContext struct { + AlterPartitionSpecificationContext +} + +func NewAlterByReorganizePartitionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByReorganizePartitionContext { + var p = new(AlterByReorganizePartitionContext) + + InitEmptyAlterPartitionSpecificationContext(&p.AlterPartitionSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterPartitionSpecificationContext)) + + return p +} + +func (s *AlterByReorganizePartitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByReorganizePartitionContext) REORGANIZE() antlr.TerminalNode { + return s.GetToken(MySqlParserREORGANIZE, 0) +} + +func (s *AlterByReorganizePartitionContext) PARTITION() antlr.TerminalNode { + return s.GetToken(MySqlParserPARTITION, 0) +} + +func (s *AlterByReorganizePartitionContext) UidList() IUidListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidListContext) +} + +func (s *AlterByReorganizePartitionContext) INTO() antlr.TerminalNode { + return s.GetToken(MySqlParserINTO, 0) +} + +func (s *AlterByReorganizePartitionContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *AlterByReorganizePartitionContext) AllPartitionDefinition() []IPartitionDefinitionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPartitionDefinitionContext); ok { + len++ + } + } + + tst := make([]IPartitionDefinitionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPartitionDefinitionContext); ok { + tst[i] = t.(IPartitionDefinitionContext) + i++ + } + } + + return tst +} + +func (s *AlterByReorganizePartitionContext) PartitionDefinition(i int) IPartitionDefinitionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionDefinitionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPartitionDefinitionContext) +} + +func (s *AlterByReorganizePartitionContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *AlterByReorganizePartitionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *AlterByReorganizePartitionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *AlterByReorganizePartitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByReorganizePartition(s) + } +} + +func (s *AlterByReorganizePartitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByReorganizePartition(s) + } +} + +type AlterByAnalyzePartitionContext struct { + AlterPartitionSpecificationContext +} + +func NewAlterByAnalyzePartitionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByAnalyzePartitionContext { + var p = new(AlterByAnalyzePartitionContext) + + InitEmptyAlterPartitionSpecificationContext(&p.AlterPartitionSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterPartitionSpecificationContext)) + + return p +} + +func (s *AlterByAnalyzePartitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByAnalyzePartitionContext) ANALYZE() antlr.TerminalNode { + return s.GetToken(MySqlParserANALYZE, 0) +} + +func (s *AlterByAnalyzePartitionContext) PARTITION() antlr.TerminalNode { + return s.GetToken(MySqlParserPARTITION, 0) +} + +func (s *AlterByAnalyzePartitionContext) UidList() IUidListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidListContext) +} + +func (s *AlterByAnalyzePartitionContext) ALL() antlr.TerminalNode { + return s.GetToken(MySqlParserALL, 0) +} + +func (s *AlterByAnalyzePartitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByAnalyzePartition(s) + } +} + +func (s *AlterByAnalyzePartitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByAnalyzePartition(s) + } +} + +type AlterByRebuildPartitionContext struct { + AlterPartitionSpecificationContext +} + +func NewAlterByRebuildPartitionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByRebuildPartitionContext { + var p = new(AlterByRebuildPartitionContext) + + InitEmptyAlterPartitionSpecificationContext(&p.AlterPartitionSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterPartitionSpecificationContext)) + + return p +} + +func (s *AlterByRebuildPartitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByRebuildPartitionContext) REBUILD() antlr.TerminalNode { + return s.GetToken(MySqlParserREBUILD, 0) +} + +func (s *AlterByRebuildPartitionContext) PARTITION() antlr.TerminalNode { + return s.GetToken(MySqlParserPARTITION, 0) +} + +func (s *AlterByRebuildPartitionContext) UidList() IUidListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidListContext) +} + +func (s *AlterByRebuildPartitionContext) ALL() antlr.TerminalNode { + return s.GetToken(MySqlParserALL, 0) +} + +func (s *AlterByRebuildPartitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByRebuildPartition(s) + } +} + +func (s *AlterByRebuildPartitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByRebuildPartition(s) + } +} + +type AlterByUpgradePartitioningContext struct { + AlterPartitionSpecificationContext +} + +func NewAlterByUpgradePartitioningContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByUpgradePartitioningContext { + var p = new(AlterByUpgradePartitioningContext) + + InitEmptyAlterPartitionSpecificationContext(&p.AlterPartitionSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterPartitionSpecificationContext)) + + return p +} + +func (s *AlterByUpgradePartitioningContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByUpgradePartitioningContext) UPGRADE() antlr.TerminalNode { + return s.GetToken(MySqlParserUPGRADE, 0) +} + +func (s *AlterByUpgradePartitioningContext) PARTITIONING() antlr.TerminalNode { + return s.GetToken(MySqlParserPARTITIONING, 0) +} + +func (s *AlterByUpgradePartitioningContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByUpgradePartitioning(s) + } +} + +func (s *AlterByUpgradePartitioningContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByUpgradePartitioning(s) + } +} + +type AlterByTruncatePartitionContext struct { + AlterPartitionSpecificationContext +} + +func NewAlterByTruncatePartitionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByTruncatePartitionContext { + var p = new(AlterByTruncatePartitionContext) + + InitEmptyAlterPartitionSpecificationContext(&p.AlterPartitionSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterPartitionSpecificationContext)) + + return p +} + +func (s *AlterByTruncatePartitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByTruncatePartitionContext) TRUNCATE() antlr.TerminalNode { + return s.GetToken(MySqlParserTRUNCATE, 0) +} + +func (s *AlterByTruncatePartitionContext) PARTITION() antlr.TerminalNode { + return s.GetToken(MySqlParserPARTITION, 0) +} + +func (s *AlterByTruncatePartitionContext) UidList() IUidListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidListContext) +} + +func (s *AlterByTruncatePartitionContext) ALL() antlr.TerminalNode { + return s.GetToken(MySqlParserALL, 0) +} + +func (s *AlterByTruncatePartitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByTruncatePartition(s) + } +} + +func (s *AlterByTruncatePartitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByTruncatePartition(s) + } +} + +type AlterByRepairPartitionContext struct { + AlterPartitionSpecificationContext +} + +func NewAlterByRepairPartitionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByRepairPartitionContext { + var p = new(AlterByRepairPartitionContext) + + InitEmptyAlterPartitionSpecificationContext(&p.AlterPartitionSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterPartitionSpecificationContext)) + + return p +} + +func (s *AlterByRepairPartitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByRepairPartitionContext) REPAIR() antlr.TerminalNode { + return s.GetToken(MySqlParserREPAIR, 0) +} + +func (s *AlterByRepairPartitionContext) PARTITION() antlr.TerminalNode { + return s.GetToken(MySqlParserPARTITION, 0) +} + +func (s *AlterByRepairPartitionContext) UidList() IUidListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidListContext) +} + +func (s *AlterByRepairPartitionContext) ALL() antlr.TerminalNode { + return s.GetToken(MySqlParserALL, 0) +} + +func (s *AlterByRepairPartitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByRepairPartition(s) + } +} + +func (s *AlterByRepairPartitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByRepairPartition(s) + } +} + +type AlterByExchangePartitionContext struct { + AlterPartitionSpecificationContext + validationFormat antlr.Token +} + +func NewAlterByExchangePartitionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterByExchangePartitionContext { + var p = new(AlterByExchangePartitionContext) + + InitEmptyAlterPartitionSpecificationContext(&p.AlterPartitionSpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*AlterPartitionSpecificationContext)) + + return p +} + +func (s *AlterByExchangePartitionContext) GetValidationFormat() antlr.Token { + return s.validationFormat +} + +func (s *AlterByExchangePartitionContext) SetValidationFormat(v antlr.Token) { s.validationFormat = v } + +func (s *AlterByExchangePartitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterByExchangePartitionContext) EXCHANGE() antlr.TerminalNode { + return s.GetToken(MySqlParserEXCHANGE, 0) +} + +func (s *AlterByExchangePartitionContext) PARTITION() antlr.TerminalNode { + return s.GetToken(MySqlParserPARTITION, 0) +} + +func (s *AlterByExchangePartitionContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *AlterByExchangePartitionContext) AllWITH() []antlr.TerminalNode { + return s.GetTokens(MySqlParserWITH) +} + +func (s *AlterByExchangePartitionContext) WITH(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserWITH, i) +} + +func (s *AlterByExchangePartitionContext) TABLE() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLE, 0) +} + +func (s *AlterByExchangePartitionContext) TableName() ITableNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableNameContext) +} + +func (s *AlterByExchangePartitionContext) VALIDATION() antlr.TerminalNode { + return s.GetToken(MySqlParserVALIDATION, 0) +} + +func (s *AlterByExchangePartitionContext) WITHOUT() antlr.TerminalNode { + return s.GetToken(MySqlParserWITHOUT, 0) +} + +func (s *AlterByExchangePartitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterByExchangePartition(s) + } +} + +func (s *AlterByExchangePartitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterByExchangePartition(s) + } +} + +func (p *MySqlParser) AlterPartitionSpecification() (localctx IAlterPartitionSpecificationContext) { + localctx = NewAlterPartitionSpecificationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 150, MySqlParserRULE_alterPartitionSpecification) + var _la int + + p.SetState(2983) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserADD: + localctx = NewAlterByAddPartitionContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2885) + p.Match(MySqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2886) + p.Match(MySqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2887) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2888) + p.PartitionDefinition() + } + p.SetState(2893) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(2889) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2890) + p.PartitionDefinition() + } + + p.SetState(2895) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2896) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserDROP: + localctx = NewAlterByDropPartitionContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2898) + p.Match(MySqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2899) + p.Match(MySqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2900) + p.UidList() + } + + case MySqlParserDISCARD: + localctx = NewAlterByDiscardPartitionContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2901) + p.Match(MySqlParserDISCARD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2902) + p.Match(MySqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2905) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserARRAY, MySqlParserATTRIBUTE, MySqlParserBUCKETS, MySqlParserCONDITION, MySqlParserCURRENT, MySqlParserCURRENT_USER, MySqlParserDATABASE, MySqlParserDEFAULT, MySqlParserDIAGNOSTICS, MySqlParserEMPTY, MySqlParserENFORCED, MySqlParserEXCEPT, MySqlParserGROUP, MySqlParserIF, MySqlParserIGNORED, MySqlParserINSERT, MySqlParserLATERAL, MySqlParserLEFT, MySqlParserNUMBER, MySqlParserOPTIONAL, MySqlParserORDER, MySqlParserPRIMARY, MySqlParserREPEAT, MySqlParserREPLACE, MySqlParserRIGHT, MySqlParserSCHEMA, MySqlParserSKIP_QUERY_REWRITE, MySqlParserSTACKED, MySqlParserSTATEMENT, MySqlParserDATE, MySqlParserTIME, MySqlParserTIMESTAMP, MySqlParserDATETIME, MySqlParserYEAR, MySqlParserBINARY, MySqlParserTEXT, MySqlParserENUM, MySqlParserSERIAL, MySqlParserJSON_ARRAY, MySqlParserJSON_ARRAYAGG, MySqlParserJSON_ARRAY_APPEND, MySqlParserJSON_ARRAY_INSERT, MySqlParserJSON_CONTAINS, MySqlParserJSON_CONTAINS_PATH, MySqlParserJSON_DEPTH, MySqlParserJSON_EXTRACT, MySqlParserJSON_INSERT, MySqlParserJSON_KEYS, MySqlParserJSON_LENGTH, MySqlParserJSON_MERGE, MySqlParserJSON_MERGE_PATCH, MySqlParserJSON_MERGE_PRESERVE, MySqlParserJSON_OBJECT, MySqlParserJSON_OBJECTAGG, MySqlParserJSON_OVERLAPS, MySqlParserJSON_PRETTY, MySqlParserJSON_QUOTE, MySqlParserJSON_REMOVE, MySqlParserJSON_REPLACE, MySqlParserJSON_SCHEMA_VALID, MySqlParserJSON_SCHEMA_VALIDATION_REPORT, MySqlParserJSON_SEARCH, MySqlParserJSON_SET, MySqlParserJSON_STORAGE_FREE, MySqlParserJSON_STORAGE_SIZE, MySqlParserJSON_TABLE, MySqlParserJSON_TYPE, MySqlParserJSON_UNQUOTE, MySqlParserJSON_VALID, MySqlParserJSON_VALUE, MySqlParserNESTED, MySqlParserORDINALITY, MySqlParserPATH, MySqlParserAVG, MySqlParserBIT_AND, MySqlParserBIT_OR, MySqlParserBIT_XOR, MySqlParserCOUNT, MySqlParserCUME_DIST, MySqlParserDENSE_RANK, MySqlParserFIRST_VALUE, MySqlParserGROUP_CONCAT, MySqlParserLAG, MySqlParserLAST_VALUE, MySqlParserLEAD, MySqlParserMAX, MySqlParserMIN, MySqlParserNTILE, MySqlParserNTH_VALUE, MySqlParserPERCENT_RANK, MySqlParserRANK, MySqlParserROW_NUMBER, MySqlParserSTD, MySqlParserSTDDEV, MySqlParserSTDDEV_POP, MySqlParserSTDDEV_SAMP, MySqlParserSUM, MySqlParserVAR_POP, MySqlParserVAR_SAMP, MySqlParserVARIANCE, MySqlParserCURRENT_DATE, MySqlParserCURRENT_TIME, MySqlParserCURRENT_TIMESTAMP, MySqlParserLOCALTIME, MySqlParserCURDATE, MySqlParserCURTIME, MySqlParserDATE_ADD, MySqlParserDATE_SUB, MySqlParserLOCALTIMESTAMP, MySqlParserNOW, MySqlParserPOSITION, MySqlParserSUBSTR, MySqlParserSUBSTRING, MySqlParserSYSDATE, MySqlParserTRIM, MySqlParserUTC_DATE, MySqlParserUTC_TIME, MySqlParserUTC_TIMESTAMP, MySqlParserACCOUNT, MySqlParserACTION, MySqlParserAFTER, MySqlParserAGGREGATE, MySqlParserALGORITHM, MySqlParserANY, MySqlParserAT, MySqlParserAUTHORS, MySqlParserAUTOCOMMIT, MySqlParserAUTOEXTEND_SIZE, MySqlParserAUTO_INCREMENT, MySqlParserAVG_ROW_LENGTH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserBIT, MySqlParserBLOCK, MySqlParserBOOL, MySqlParserBOOLEAN, MySqlParserBTREE, MySqlParserCACHE, MySqlParserCASCADED, MySqlParserCHAIN, MySqlParserCHANGED, MySqlParserCHANNEL, MySqlParserCHECKSUM, MySqlParserPAGE_CHECKSUM, MySqlParserCIPHER, MySqlParserCLASS_ORIGIN, MySqlParserCLIENT, MySqlParserCLOSE, MySqlParserCLUSTERING, MySqlParserCOALESCE, MySqlParserCODE, MySqlParserCOLUMNS, MySqlParserCOLUMN_FORMAT, MySqlParserCOLUMN_NAME, MySqlParserCOMMENT, MySqlParserCOMMIT, MySqlParserCOMPACT, MySqlParserCOMPLETION, MySqlParserCOMPRESSED, MySqlParserCOMPRESSION, MySqlParserCONCURRENT, MySqlParserCONNECT, MySqlParserCONNECTION, MySqlParserCONSISTENT, MySqlParserCONSTRAINT_CATALOG, MySqlParserCONSTRAINT_SCHEMA, MySqlParserCONSTRAINT_NAME, MySqlParserCONTAINS, MySqlParserCONTEXT, MySqlParserCONTRIBUTORS, MySqlParserCOPY, MySqlParserCPU, MySqlParserCURSOR_NAME, MySqlParserDATA, MySqlParserDATAFILE, MySqlParserDEALLOCATE, MySqlParserDEFAULT_AUTH, MySqlParserDEFINER, MySqlParserDELAY_KEY_WRITE, MySqlParserDES_KEY_FILE, MySqlParserDIRECTORY, MySqlParserDISABLE, MySqlParserDISCARD, MySqlParserDISK, MySqlParserDO, MySqlParserDUMPFILE, MySqlParserDUPLICATE, MySqlParserDYNAMIC, MySqlParserENABLE, MySqlParserENCRYPTION, MySqlParserEND, MySqlParserENDS, MySqlParserENGINE, MySqlParserENGINES, MySqlParserERROR, MySqlParserERRORS, MySqlParserESCAPE, MySqlParserEVEN, MySqlParserEVENT, MySqlParserEVENTS, MySqlParserEVERY, MySqlParserEXCHANGE, MySqlParserEXCLUSIVE, MySqlParserEXPIRE, MySqlParserEXPORT, MySqlParserEXTENDED, MySqlParserEXTENT_SIZE, MySqlParserFAILED_LOGIN_ATTEMPTS, MySqlParserFAST, MySqlParserFAULTS, MySqlParserFIELDS, MySqlParserFILE_BLOCK_SIZE, MySqlParserFILTER, MySqlParserFIRST, MySqlParserFIXED, MySqlParserFLUSH, MySqlParserFOLLOWS, MySqlParserFOUND, MySqlParserFULL, MySqlParserFUNCTION, MySqlParserGENERAL, MySqlParserGLOBAL, MySqlParserGRANTS, MySqlParserGROUP_REPLICATION, MySqlParserHANDLER, MySqlParserHASH, MySqlParserHELP, MySqlParserHISTORY, MySqlParserHOST, MySqlParserHOSTS, MySqlParserIDENTIFIED, MySqlParserIGNORE_SERVER_IDS, MySqlParserIMPORT, MySqlParserINDEXES, MySqlParserINITIAL_SIZE, MySqlParserINPLACE, MySqlParserINSERT_METHOD, MySqlParserINSTALL, MySqlParserINSTANCE, MySqlParserINSTANT, MySqlParserINVISIBLE, MySqlParserINVOKER, MySqlParserIO, MySqlParserIO_THREAD, MySqlParserIPC, MySqlParserISOLATION, MySqlParserISSUER, MySqlParserJSON, MySqlParserKEY_BLOCK_SIZE, MySqlParserLANGUAGE, MySqlParserLAST, MySqlParserLEAVES, MySqlParserLESS, MySqlParserLEVEL, MySqlParserLIST, MySqlParserLOCAL, MySqlParserLOGFILE, MySqlParserLOGS, MySqlParserMASTER, MySqlParserMASTER_AUTO_POSITION, MySqlParserMASTER_CONNECT_RETRY, MySqlParserMASTER_DELAY, MySqlParserMASTER_HEARTBEAT_PERIOD, MySqlParserMASTER_HOST, MySqlParserMASTER_LOG_FILE, MySqlParserMASTER_LOG_POS, MySqlParserMASTER_PASSWORD, MySqlParserMASTER_PORT, MySqlParserMASTER_RETRY_COUNT, MySqlParserMASTER_SSL, MySqlParserMASTER_SSL_CA, MySqlParserMASTER_SSL_CAPATH, MySqlParserMASTER_SSL_CERT, MySqlParserMASTER_SSL_CIPHER, MySqlParserMASTER_SSL_CRL, MySqlParserMASTER_SSL_CRLPATH, MySqlParserMASTER_SSL_KEY, MySqlParserMASTER_TLS_VERSION, MySqlParserMASTER_USER, MySqlParserMAX_CONNECTIONS_PER_HOUR, MySqlParserMAX_QUERIES_PER_HOUR, MySqlParserMAX_ROWS, MySqlParserMAX_SIZE, MySqlParserMAX_UPDATES_PER_HOUR, MySqlParserMAX_USER_CONNECTIONS, MySqlParserMEDIUM, MySqlParserMEMBER, MySqlParserMERGE, MySqlParserMESSAGE_TEXT, MySqlParserMID, MySqlParserMIGRATE, MySqlParserMIN_ROWS, MySqlParserMODE, MySqlParserMODIFY, MySqlParserMUTEX, MySqlParserMYSQL, MySqlParserMYSQL_ERRNO, MySqlParserNAME, MySqlParserNAMES, MySqlParserNCHAR, MySqlParserNEVER, MySqlParserNEXT, MySqlParserNO, MySqlParserNOCOPY, MySqlParserNOWAIT, MySqlParserNODEGROUP, MySqlParserNONE, MySqlParserODBC, MySqlParserOFFLINE, MySqlParserOFFSET, MySqlParserOF, MySqlParserOJ, MySqlParserOLD_PASSWORD, MySqlParserONE, MySqlParserONLINE, MySqlParserONLY, MySqlParserOPEN, MySqlParserOPTIMIZER_COSTS, MySqlParserOPTIONS, MySqlParserOWNER, MySqlParserPACK_KEYS, MySqlParserPAGE, MySqlParserPARSER, MySqlParserPARTIAL, MySqlParserPARTITIONING, MySqlParserPARTITIONS, MySqlParserPASSWORD, MySqlParserPASSWORD_LOCK_TIME, MySqlParserPHASE, MySqlParserPLUGIN, MySqlParserPLUGIN_DIR, MySqlParserPLUGINS, MySqlParserPORT, MySqlParserPRECEDES, MySqlParserPREPARE, MySqlParserPRESERVE, MySqlParserPREV, MySqlParserPROCESSLIST, MySqlParserPROFILE, MySqlParserPROFILES, MySqlParserPROXY, MySqlParserQUERY, MySqlParserQUICK, MySqlParserREBUILD, MySqlParserRECOVER, MySqlParserRECURSIVE, MySqlParserREDO_BUFFER_SIZE, MySqlParserREDUNDANT, MySqlParserRELAY, MySqlParserRELAY_LOG_FILE, MySqlParserRELAY_LOG_POS, MySqlParserRELAYLOG, MySqlParserREMOVE, MySqlParserREORGANIZE, MySqlParserREPAIR, MySqlParserREPLICATE_DO_DB, MySqlParserREPLICATE_DO_TABLE, MySqlParserREPLICATE_IGNORE_DB, MySqlParserREPLICATE_IGNORE_TABLE, MySqlParserREPLICATE_REWRITE_DB, MySqlParserREPLICATE_WILD_DO_TABLE, MySqlParserREPLICATE_WILD_IGNORE_TABLE, MySqlParserREPLICATION, MySqlParserRESET, MySqlParserRESUME, MySqlParserRETURNED_SQLSTATE, MySqlParserRETURNING, MySqlParserRETURNS, MySqlParserREUSE, MySqlParserROLE, MySqlParserROLLBACK, MySqlParserROLLUP, MySqlParserROTATE, MySqlParserROW, MySqlParserROWS, MySqlParserROW_FORMAT, MySqlParserRTREE, MySqlParserSAVEPOINT, MySqlParserSCHEDULE, MySqlParserSECURITY, MySqlParserSERVER, MySqlParserSESSION, MySqlParserSHARE, MySqlParserSHARED, MySqlParserSIGNED, MySqlParserSIMPLE, MySqlParserSLAVE, MySqlParserSLOW, MySqlParserSNAPSHOT, MySqlParserSOCKET, MySqlParserSOME, MySqlParserSONAME, MySqlParserSOUNDS, MySqlParserSOURCE, MySqlParserSQL_AFTER_GTIDS, MySqlParserSQL_AFTER_MTS_GAPS, MySqlParserSQL_BEFORE_GTIDS, MySqlParserSQL_BUFFER_RESULT, MySqlParserSQL_CACHE, MySqlParserSQL_NO_CACHE, MySqlParserSQL_THREAD, MySqlParserSTART, MySqlParserSTARTS, MySqlParserSTATS_AUTO_RECALC, MySqlParserSTATS_PERSISTENT, MySqlParserSTATS_SAMPLE_PAGES, MySqlParserSTATUS, MySqlParserSTOP, MySqlParserSTORAGE, MySqlParserSTRING, MySqlParserSUBCLASS_ORIGIN, MySqlParserSUBJECT, MySqlParserSUBPARTITION, MySqlParserSUBPARTITIONS, MySqlParserSUSPEND, MySqlParserSWAPS, MySqlParserSWITCHES, MySqlParserTABLE_NAME, MySqlParserTABLESPACE, MySqlParserTABLE_TYPE, MySqlParserTEMPORARY, MySqlParserTEMPTABLE, MySqlParserTHAN, MySqlParserTRADITIONAL, MySqlParserTRANSACTION, MySqlParserTRANSACTIONAL, MySqlParserTRIGGERS, MySqlParserTRUNCATE, MySqlParserUNBOUNDED, MySqlParserUNDEFINED, MySqlParserUNDOFILE, MySqlParserUNDO_BUFFER_SIZE, MySqlParserUNINSTALL, MySqlParserUNKNOWN, MySqlParserUNTIL, MySqlParserUPGRADE, MySqlParserUSER, MySqlParserUSE_FRM, MySqlParserUSER_RESOURCES, MySqlParserVALIDATION, MySqlParserVALUE, MySqlParserVARIABLES, MySqlParserVIEW, MySqlParserVIRTUAL, MySqlParserVISIBLE, MySqlParserWAIT, MySqlParserWARNINGS, MySqlParserWITHOUT, MySqlParserWORK, MySqlParserWRAPPER, MySqlParserX509, MySqlParserXA, MySqlParserXML, MySqlParserYES, MySqlParserEUR, MySqlParserUSA, MySqlParserJIS, MySqlParserISO, MySqlParserINTERNAL, MySqlParserQUARTER, MySqlParserMONTH, MySqlParserDAY, MySqlParserHOUR, MySqlParserMINUTE, MySqlParserWEEK, MySqlParserSECOND, MySqlParserMICROSECOND, MySqlParserADMIN, MySqlParserAUDIT_ABORT_EXEMPT, MySqlParserAUDIT_ADMIN, MySqlParserAUTHENTICATION_POLICY_ADMIN, MySqlParserBACKUP_ADMIN, MySqlParserBINLOG_ADMIN, MySqlParserBINLOG_ENCRYPTION_ADMIN, MySqlParserCLONE_ADMIN, MySqlParserCONNECTION_ADMIN, MySqlParserENCRYPTION_KEY_ADMIN, MySqlParserEXECUTE, MySqlParserFILE, MySqlParserFIREWALL_ADMIN, MySqlParserFIREWALL_EXEMPT, MySqlParserFIREWALL_USER, MySqlParserGROUP_REPLICATION_ADMIN, MySqlParserINNODB_REDO_LOG_ARCHIVE, MySqlParserINVOKE, MySqlParserLAMBDA, MySqlParserNDB_STORED_USER, MySqlParserPASSWORDLESS_USER_ADMIN, MySqlParserPERSIST_RO_VARIABLES_ADMIN, MySqlParserPRIVILEGES, MySqlParserPROCESS, MySqlParserRELOAD, MySqlParserREPLICATION_APPLIER, MySqlParserREPLICATION_SLAVE_ADMIN, MySqlParserRESOURCE_GROUP_ADMIN, MySqlParserRESOURCE_GROUP_USER, MySqlParserROLE_ADMIN, MySqlParserROUTINE, MySqlParserS3, MySqlParserSESSION_VARIABLES_ADMIN, MySqlParserSET_USER_ID, MySqlParserSHOW_ROUTINE, MySqlParserSHUTDOWN, MySqlParserSUPER, MySqlParserSYSTEM_VARIABLES_ADMIN, MySqlParserTABLES, MySqlParserTABLE_ENCRYPTION_ADMIN, MySqlParserVERSION_TOKEN_ADMIN, MySqlParserXA_RECOVER_ADMIN, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserARCHIVE, MySqlParserBLACKHOLE, MySqlParserCSV, MySqlParserFEDERATED, MySqlParserINNODB, MySqlParserMEMORY, MySqlParserMRG_MYISAM, MySqlParserMYISAM, MySqlParserNDB, MySqlParserNDBCLUSTER, MySqlParserPERFORMANCE_SCHEMA, MySqlParserTOKUDB, MySqlParserREPEATABLE, MySqlParserCOMMITTED, MySqlParserUNCOMMITTED, MySqlParserSERIALIZABLE, MySqlParserGEOMETRYCOLLECTION, MySqlParserLINESTRING, MySqlParserMULTILINESTRING, MySqlParserMULTIPOINT, MySqlParserMULTIPOLYGON, MySqlParserPOINT, MySqlParserPOLYGON, MySqlParserABS, MySqlParserACOS, MySqlParserADDDATE, MySqlParserADDTIME, MySqlParserAES_DECRYPT, MySqlParserAES_ENCRYPT, MySqlParserAREA, MySqlParserASBINARY, MySqlParserASIN, MySqlParserASTEXT, MySqlParserASWKB, MySqlParserASWKT, MySqlParserASYMMETRIC_DECRYPT, MySqlParserASYMMETRIC_DERIVE, MySqlParserASYMMETRIC_ENCRYPT, MySqlParserASYMMETRIC_SIGN, MySqlParserASYMMETRIC_VERIFY, MySqlParserATAN, MySqlParserATAN2, MySqlParserBENCHMARK, MySqlParserBIN, MySqlParserBIT_COUNT, MySqlParserBIT_LENGTH, MySqlParserBUFFER, MySqlParserCATALOG_NAME, MySqlParserCEIL, MySqlParserCEILING, MySqlParserCENTROID, MySqlParserCHARACTER_LENGTH, MySqlParserCHARSET, MySqlParserCHAR_LENGTH, MySqlParserCOERCIBILITY, MySqlParserCOLLATION, MySqlParserCOMPRESS, MySqlParserCONCAT, MySqlParserCONCAT_WS, MySqlParserCONNECTION_ID, MySqlParserCONV, MySqlParserCONVERT_TZ, MySqlParserCOS, MySqlParserCOT, MySqlParserCRC32, MySqlParserCREATE_ASYMMETRIC_PRIV_KEY, MySqlParserCREATE_ASYMMETRIC_PUB_KEY, MySqlParserCREATE_DH_PARAMETERS, MySqlParserCREATE_DIGEST, MySqlParserCROSSES, MySqlParserDATEDIFF, MySqlParserDATE_FORMAT, MySqlParserDAYNAME, MySqlParserDAYOFMONTH, MySqlParserDAYOFWEEK, MySqlParserDAYOFYEAR, MySqlParserDECODE, MySqlParserDEGREES, MySqlParserDES_DECRYPT, MySqlParserDES_ENCRYPT, MySqlParserDIMENSION, MySqlParserDISJOINT, MySqlParserDISTANCE, MySqlParserELT, MySqlParserENCODE, MySqlParserENCRYPT, MySqlParserENDPOINT, MySqlParserENGINE_ATTRIBUTE, MySqlParserENVELOPE, MySqlParserEQUALS, MySqlParserEXP, MySqlParserEXPORT_SET, MySqlParserEXTERIORRING, MySqlParserEXTRACTVALUE, MySqlParserFIELD, MySqlParserFIND_IN_SET, MySqlParserFLOOR, MySqlParserFORMAT, MySqlParserFOUND_ROWS, MySqlParserFROM_BASE64, MySqlParserFROM_DAYS, MySqlParserFROM_UNIXTIME, MySqlParserGEOMCOLLFROMTEXT, MySqlParserGEOMCOLLFROMWKB, MySqlParserGEOMETRYCOLLECTIONFROMTEXT, MySqlParserGEOMETRYCOLLECTIONFROMWKB, MySqlParserGEOMETRYFROMTEXT, MySqlParserGEOMETRYFROMWKB, MySqlParserGEOMETRYN, MySqlParserGEOMETRYTYPE, MySqlParserGEOMFROMTEXT, MySqlParserGEOMFROMWKB, MySqlParserGET_FORMAT, MySqlParserGET_LOCK, MySqlParserGLENGTH, MySqlParserGREATEST, MySqlParserGTID_SUBSET, MySqlParserGTID_SUBTRACT, MySqlParserHEX, MySqlParserIFNULL, MySqlParserINET6_ATON, MySqlParserINET6_NTOA, MySqlParserINET_ATON, MySqlParserINET_NTOA, MySqlParserINSTR, MySqlParserINTERIORRINGN, MySqlParserINTERSECTS, MySqlParserISCLOSED, MySqlParserISEMPTY, MySqlParserISNULL, MySqlParserISSIMPLE, MySqlParserIS_FREE_LOCK, MySqlParserIS_IPV4, MySqlParserIS_IPV4_COMPAT, MySqlParserIS_IPV4_MAPPED, MySqlParserIS_IPV6, MySqlParserIS_USED_LOCK, MySqlParserLAST_INSERT_ID, MySqlParserLCASE, MySqlParserLEAST, MySqlParserLENGTH, MySqlParserLINEFROMTEXT, MySqlParserLINEFROMWKB, MySqlParserLINESTRINGFROMTEXT, MySqlParserLINESTRINGFROMWKB, MySqlParserLN, MySqlParserLOAD_FILE, MySqlParserLOCATE, MySqlParserLOG, MySqlParserLOG10, MySqlParserLOG2, MySqlParserLOWER, MySqlParserLPAD, MySqlParserLTRIM, MySqlParserMAKEDATE, MySqlParserMAKETIME, MySqlParserMAKE_SET, MySqlParserMASTER_POS_WAIT, MySqlParserMBRCONTAINS, MySqlParserMBRDISJOINT, MySqlParserMBREQUAL, MySqlParserMBRINTERSECTS, MySqlParserMBROVERLAPS, MySqlParserMBRTOUCHES, MySqlParserMBRWITHIN, MySqlParserMD5, MySqlParserMLINEFROMTEXT, MySqlParserMLINEFROMWKB, MySqlParserMONTHNAME, MySqlParserMPOINTFROMTEXT, MySqlParserMPOINTFROMWKB, MySqlParserMPOLYFROMTEXT, MySqlParserMPOLYFROMWKB, MySqlParserMULTILINESTRINGFROMTEXT, MySqlParserMULTILINESTRINGFROMWKB, MySqlParserMULTIPOINTFROMTEXT, MySqlParserMULTIPOINTFROMWKB, MySqlParserMULTIPOLYGONFROMTEXT, MySqlParserMULTIPOLYGONFROMWKB, MySqlParserNAME_CONST, MySqlParserNULLIF, MySqlParserNUMGEOMETRIES, MySqlParserNUMINTERIORRINGS, MySqlParserNUMPOINTS, MySqlParserOCT, MySqlParserOCTET_LENGTH, MySqlParserORD, MySqlParserOVERLAPS, MySqlParserPERIOD_ADD, MySqlParserPERIOD_DIFF, MySqlParserPI, MySqlParserPOINTFROMTEXT, MySqlParserPOINTFROMWKB, MySqlParserPOINTN, MySqlParserPOLYFROMTEXT, MySqlParserPOLYFROMWKB, MySqlParserPOLYGONFROMTEXT, MySqlParserPOLYGONFROMWKB, MySqlParserPOW, MySqlParserPOWER, MySqlParserQUOTE, MySqlParserRADIANS, MySqlParserRAND, MySqlParserRANDOM, MySqlParserRANDOM_BYTES, MySqlParserRELEASE_LOCK, MySqlParserREVERSE, MySqlParserROUND, MySqlParserROW_COUNT, MySqlParserRPAD, MySqlParserRTRIM, MySqlParserSEC_TO_TIME, MySqlParserSECONDARY_ENGINE_ATTRIBUTE, MySqlParserSESSION_USER, MySqlParserSHA, MySqlParserSHA1, MySqlParserSHA2, MySqlParserSCHEMA_NAME, MySqlParserSIGN, MySqlParserSIN, MySqlParserSLEEP, MySqlParserSOUNDEX, MySqlParserSQL_THREAD_WAIT_AFTER_GTIDS, MySqlParserSQRT, MySqlParserSRID, MySqlParserSTARTPOINT, MySqlParserSTRCMP, MySqlParserSTR_TO_DATE, MySqlParserST_AREA, MySqlParserST_ASBINARY, MySqlParserST_ASTEXT, MySqlParserST_ASWKB, MySqlParserST_ASWKT, MySqlParserST_BUFFER, MySqlParserST_CENTROID, MySqlParserST_CONTAINS, MySqlParserST_CROSSES, MySqlParserST_DIFFERENCE, MySqlParserST_DIMENSION, MySqlParserST_DISJOINT, MySqlParserST_DISTANCE, MySqlParserST_ENDPOINT, MySqlParserST_ENVELOPE, MySqlParserST_EQUALS, MySqlParserST_EXTERIORRING, MySqlParserST_GEOMCOLLFROMTEXT, MySqlParserST_GEOMCOLLFROMTXT, MySqlParserST_GEOMCOLLFROMWKB, MySqlParserST_GEOMETRYCOLLECTIONFROMTEXT, MySqlParserST_GEOMETRYCOLLECTIONFROMWKB, MySqlParserST_GEOMETRYFROMTEXT, MySqlParserST_GEOMETRYFROMWKB, MySqlParserST_GEOMETRYN, MySqlParserST_GEOMETRYTYPE, MySqlParserST_GEOMFROMTEXT, MySqlParserST_GEOMFROMWKB, MySqlParserST_INTERIORRINGN, MySqlParserST_INTERSECTION, MySqlParserST_INTERSECTS, MySqlParserST_ISCLOSED, MySqlParserST_ISEMPTY, MySqlParserST_ISSIMPLE, MySqlParserST_LINEFROMTEXT, MySqlParserST_LINEFROMWKB, MySqlParserST_LINESTRINGFROMTEXT, MySqlParserST_LINESTRINGFROMWKB, MySqlParserST_NUMGEOMETRIES, MySqlParserST_NUMINTERIORRING, MySqlParserST_NUMINTERIORRINGS, MySqlParserST_NUMPOINTS, MySqlParserST_OVERLAPS, MySqlParserST_POINTFROMTEXT, MySqlParserST_POINTFROMWKB, MySqlParserST_POINTN, MySqlParserST_POLYFROMTEXT, MySqlParserST_POLYFROMWKB, MySqlParserST_POLYGONFROMTEXT, MySqlParserST_POLYGONFROMWKB, MySqlParserST_SRID, MySqlParserST_STARTPOINT, MySqlParserST_SYMDIFFERENCE, MySqlParserST_TOUCHES, MySqlParserST_UNION, MySqlParserST_WITHIN, MySqlParserST_X, MySqlParserST_Y, MySqlParserSTRING_TO_VECTOR, MySqlParserSUBDATE, MySqlParserSUBSTRING_INDEX, MySqlParserSUBTIME, MySqlParserSYSTEM_USER, MySqlParserTAN, MySqlParserTIMEDIFF, MySqlParserTIMESTAMPADD, MySqlParserTIMESTAMPDIFF, MySqlParserTIME_FORMAT, MySqlParserTIME_TO_SEC, MySqlParserTOUCHES, MySqlParserTO_BASE64, MySqlParserTO_DAYS, MySqlParserTO_SECONDS, MySqlParserTP_CONNECTION_ADMIN, MySqlParserUCASE, MySqlParserUNCOMPRESS, MySqlParserUNCOMPRESSED_LENGTH, MySqlParserUNHEX, MySqlParserUNIX_TIMESTAMP, MySqlParserUPDATEXML, MySqlParserUPPER, MySqlParserUUID, MySqlParserUUID_SHORT, MySqlParserVALIDATE_PASSWORD_STRENGTH, MySqlParserVECTOR_DIM, MySqlParserVECTOR_TO_STRING, MySqlParserVERSION, MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS, MySqlParserWEEKDAY, MySqlParserWEEKOFYEAR, MySqlParserWEIGHT_STRING, MySqlParserWITHIN, MySqlParserYEARWEEK, MySqlParserY_FUNCTION, MySqlParserX_FUNCTION, MySqlParserMOD, MySqlParserCHARSET_REVERSE_QOUTE_STRING, MySqlParserSTRING_LITERAL, MySqlParserID: + { + p.SetState(2903) + p.UidList() + } + + case MySqlParserALL: + { + p.SetState(2904) + p.Match(MySqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(2907) + p.Match(MySqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserIMPORT: + localctx = NewAlterByImportPartitionContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(2908) + p.Match(MySqlParserIMPORT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2909) + p.Match(MySqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2912) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserARRAY, MySqlParserATTRIBUTE, MySqlParserBUCKETS, MySqlParserCONDITION, MySqlParserCURRENT, MySqlParserCURRENT_USER, MySqlParserDATABASE, MySqlParserDEFAULT, MySqlParserDIAGNOSTICS, MySqlParserEMPTY, MySqlParserENFORCED, MySqlParserEXCEPT, MySqlParserGROUP, MySqlParserIF, MySqlParserIGNORED, MySqlParserINSERT, MySqlParserLATERAL, MySqlParserLEFT, MySqlParserNUMBER, MySqlParserOPTIONAL, MySqlParserORDER, MySqlParserPRIMARY, MySqlParserREPEAT, MySqlParserREPLACE, MySqlParserRIGHT, MySqlParserSCHEMA, MySqlParserSKIP_QUERY_REWRITE, MySqlParserSTACKED, MySqlParserSTATEMENT, MySqlParserDATE, MySqlParserTIME, MySqlParserTIMESTAMP, MySqlParserDATETIME, MySqlParserYEAR, MySqlParserBINARY, MySqlParserTEXT, MySqlParserENUM, MySqlParserSERIAL, MySqlParserJSON_ARRAY, MySqlParserJSON_ARRAYAGG, MySqlParserJSON_ARRAY_APPEND, MySqlParserJSON_ARRAY_INSERT, MySqlParserJSON_CONTAINS, MySqlParserJSON_CONTAINS_PATH, MySqlParserJSON_DEPTH, MySqlParserJSON_EXTRACT, MySqlParserJSON_INSERT, MySqlParserJSON_KEYS, MySqlParserJSON_LENGTH, MySqlParserJSON_MERGE, MySqlParserJSON_MERGE_PATCH, MySqlParserJSON_MERGE_PRESERVE, MySqlParserJSON_OBJECT, MySqlParserJSON_OBJECTAGG, MySqlParserJSON_OVERLAPS, MySqlParserJSON_PRETTY, MySqlParserJSON_QUOTE, MySqlParserJSON_REMOVE, MySqlParserJSON_REPLACE, MySqlParserJSON_SCHEMA_VALID, MySqlParserJSON_SCHEMA_VALIDATION_REPORT, MySqlParserJSON_SEARCH, MySqlParserJSON_SET, MySqlParserJSON_STORAGE_FREE, MySqlParserJSON_STORAGE_SIZE, MySqlParserJSON_TABLE, MySqlParserJSON_TYPE, MySqlParserJSON_UNQUOTE, MySqlParserJSON_VALID, MySqlParserJSON_VALUE, MySqlParserNESTED, MySqlParserORDINALITY, MySqlParserPATH, MySqlParserAVG, MySqlParserBIT_AND, MySqlParserBIT_OR, MySqlParserBIT_XOR, MySqlParserCOUNT, MySqlParserCUME_DIST, MySqlParserDENSE_RANK, MySqlParserFIRST_VALUE, MySqlParserGROUP_CONCAT, MySqlParserLAG, MySqlParserLAST_VALUE, MySqlParserLEAD, MySqlParserMAX, MySqlParserMIN, MySqlParserNTILE, MySqlParserNTH_VALUE, MySqlParserPERCENT_RANK, MySqlParserRANK, MySqlParserROW_NUMBER, MySqlParserSTD, MySqlParserSTDDEV, MySqlParserSTDDEV_POP, MySqlParserSTDDEV_SAMP, MySqlParserSUM, MySqlParserVAR_POP, MySqlParserVAR_SAMP, MySqlParserVARIANCE, MySqlParserCURRENT_DATE, MySqlParserCURRENT_TIME, MySqlParserCURRENT_TIMESTAMP, MySqlParserLOCALTIME, MySqlParserCURDATE, MySqlParserCURTIME, MySqlParserDATE_ADD, MySqlParserDATE_SUB, MySqlParserLOCALTIMESTAMP, MySqlParserNOW, MySqlParserPOSITION, MySqlParserSUBSTR, MySqlParserSUBSTRING, MySqlParserSYSDATE, MySqlParserTRIM, MySqlParserUTC_DATE, MySqlParserUTC_TIME, MySqlParserUTC_TIMESTAMP, MySqlParserACCOUNT, MySqlParserACTION, MySqlParserAFTER, MySqlParserAGGREGATE, MySqlParserALGORITHM, MySqlParserANY, MySqlParserAT, MySqlParserAUTHORS, MySqlParserAUTOCOMMIT, MySqlParserAUTOEXTEND_SIZE, MySqlParserAUTO_INCREMENT, MySqlParserAVG_ROW_LENGTH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserBIT, MySqlParserBLOCK, MySqlParserBOOL, MySqlParserBOOLEAN, MySqlParserBTREE, MySqlParserCACHE, MySqlParserCASCADED, MySqlParserCHAIN, MySqlParserCHANGED, MySqlParserCHANNEL, MySqlParserCHECKSUM, MySqlParserPAGE_CHECKSUM, MySqlParserCIPHER, MySqlParserCLASS_ORIGIN, MySqlParserCLIENT, MySqlParserCLOSE, MySqlParserCLUSTERING, MySqlParserCOALESCE, MySqlParserCODE, MySqlParserCOLUMNS, MySqlParserCOLUMN_FORMAT, MySqlParserCOLUMN_NAME, MySqlParserCOMMENT, MySqlParserCOMMIT, MySqlParserCOMPACT, MySqlParserCOMPLETION, MySqlParserCOMPRESSED, MySqlParserCOMPRESSION, MySqlParserCONCURRENT, MySqlParserCONNECT, MySqlParserCONNECTION, MySqlParserCONSISTENT, MySqlParserCONSTRAINT_CATALOG, MySqlParserCONSTRAINT_SCHEMA, MySqlParserCONSTRAINT_NAME, MySqlParserCONTAINS, MySqlParserCONTEXT, MySqlParserCONTRIBUTORS, MySqlParserCOPY, MySqlParserCPU, MySqlParserCURSOR_NAME, MySqlParserDATA, MySqlParserDATAFILE, MySqlParserDEALLOCATE, MySqlParserDEFAULT_AUTH, MySqlParserDEFINER, MySqlParserDELAY_KEY_WRITE, MySqlParserDES_KEY_FILE, MySqlParserDIRECTORY, MySqlParserDISABLE, MySqlParserDISCARD, MySqlParserDISK, MySqlParserDO, MySqlParserDUMPFILE, MySqlParserDUPLICATE, MySqlParserDYNAMIC, MySqlParserENABLE, MySqlParserENCRYPTION, MySqlParserEND, MySqlParserENDS, MySqlParserENGINE, MySqlParserENGINES, MySqlParserERROR, MySqlParserERRORS, MySqlParserESCAPE, MySqlParserEVEN, MySqlParserEVENT, MySqlParserEVENTS, MySqlParserEVERY, MySqlParserEXCHANGE, MySqlParserEXCLUSIVE, MySqlParserEXPIRE, MySqlParserEXPORT, MySqlParserEXTENDED, MySqlParserEXTENT_SIZE, MySqlParserFAILED_LOGIN_ATTEMPTS, MySqlParserFAST, MySqlParserFAULTS, MySqlParserFIELDS, MySqlParserFILE_BLOCK_SIZE, MySqlParserFILTER, MySqlParserFIRST, MySqlParserFIXED, MySqlParserFLUSH, MySqlParserFOLLOWS, MySqlParserFOUND, MySqlParserFULL, MySqlParserFUNCTION, MySqlParserGENERAL, MySqlParserGLOBAL, MySqlParserGRANTS, MySqlParserGROUP_REPLICATION, MySqlParserHANDLER, MySqlParserHASH, MySqlParserHELP, MySqlParserHISTORY, MySqlParserHOST, MySqlParserHOSTS, MySqlParserIDENTIFIED, MySqlParserIGNORE_SERVER_IDS, MySqlParserIMPORT, MySqlParserINDEXES, MySqlParserINITIAL_SIZE, MySqlParserINPLACE, MySqlParserINSERT_METHOD, MySqlParserINSTALL, MySqlParserINSTANCE, MySqlParserINSTANT, MySqlParserINVISIBLE, MySqlParserINVOKER, MySqlParserIO, MySqlParserIO_THREAD, MySqlParserIPC, MySqlParserISOLATION, MySqlParserISSUER, MySqlParserJSON, MySqlParserKEY_BLOCK_SIZE, MySqlParserLANGUAGE, MySqlParserLAST, MySqlParserLEAVES, MySqlParserLESS, MySqlParserLEVEL, MySqlParserLIST, MySqlParserLOCAL, MySqlParserLOGFILE, MySqlParserLOGS, MySqlParserMASTER, MySqlParserMASTER_AUTO_POSITION, MySqlParserMASTER_CONNECT_RETRY, MySqlParserMASTER_DELAY, MySqlParserMASTER_HEARTBEAT_PERIOD, MySqlParserMASTER_HOST, MySqlParserMASTER_LOG_FILE, MySqlParserMASTER_LOG_POS, MySqlParserMASTER_PASSWORD, MySqlParserMASTER_PORT, MySqlParserMASTER_RETRY_COUNT, MySqlParserMASTER_SSL, MySqlParserMASTER_SSL_CA, MySqlParserMASTER_SSL_CAPATH, MySqlParserMASTER_SSL_CERT, MySqlParserMASTER_SSL_CIPHER, MySqlParserMASTER_SSL_CRL, MySqlParserMASTER_SSL_CRLPATH, MySqlParserMASTER_SSL_KEY, MySqlParserMASTER_TLS_VERSION, MySqlParserMASTER_USER, MySqlParserMAX_CONNECTIONS_PER_HOUR, MySqlParserMAX_QUERIES_PER_HOUR, MySqlParserMAX_ROWS, MySqlParserMAX_SIZE, MySqlParserMAX_UPDATES_PER_HOUR, MySqlParserMAX_USER_CONNECTIONS, MySqlParserMEDIUM, MySqlParserMEMBER, MySqlParserMERGE, MySqlParserMESSAGE_TEXT, MySqlParserMID, MySqlParserMIGRATE, MySqlParserMIN_ROWS, MySqlParserMODE, MySqlParserMODIFY, MySqlParserMUTEX, MySqlParserMYSQL, MySqlParserMYSQL_ERRNO, MySqlParserNAME, MySqlParserNAMES, MySqlParserNCHAR, MySqlParserNEVER, MySqlParserNEXT, MySqlParserNO, MySqlParserNOCOPY, MySqlParserNOWAIT, MySqlParserNODEGROUP, MySqlParserNONE, MySqlParserODBC, MySqlParserOFFLINE, MySqlParserOFFSET, MySqlParserOF, MySqlParserOJ, MySqlParserOLD_PASSWORD, MySqlParserONE, MySqlParserONLINE, MySqlParserONLY, MySqlParserOPEN, MySqlParserOPTIMIZER_COSTS, MySqlParserOPTIONS, MySqlParserOWNER, MySqlParserPACK_KEYS, MySqlParserPAGE, MySqlParserPARSER, MySqlParserPARTIAL, MySqlParserPARTITIONING, MySqlParserPARTITIONS, MySqlParserPASSWORD, MySqlParserPASSWORD_LOCK_TIME, MySqlParserPHASE, MySqlParserPLUGIN, MySqlParserPLUGIN_DIR, MySqlParserPLUGINS, MySqlParserPORT, MySqlParserPRECEDES, MySqlParserPREPARE, MySqlParserPRESERVE, MySqlParserPREV, MySqlParserPROCESSLIST, MySqlParserPROFILE, MySqlParserPROFILES, MySqlParserPROXY, MySqlParserQUERY, MySqlParserQUICK, MySqlParserREBUILD, MySqlParserRECOVER, MySqlParserRECURSIVE, MySqlParserREDO_BUFFER_SIZE, MySqlParserREDUNDANT, MySqlParserRELAY, MySqlParserRELAY_LOG_FILE, MySqlParserRELAY_LOG_POS, MySqlParserRELAYLOG, MySqlParserREMOVE, MySqlParserREORGANIZE, MySqlParserREPAIR, MySqlParserREPLICATE_DO_DB, MySqlParserREPLICATE_DO_TABLE, MySqlParserREPLICATE_IGNORE_DB, MySqlParserREPLICATE_IGNORE_TABLE, MySqlParserREPLICATE_REWRITE_DB, MySqlParserREPLICATE_WILD_DO_TABLE, MySqlParserREPLICATE_WILD_IGNORE_TABLE, MySqlParserREPLICATION, MySqlParserRESET, MySqlParserRESUME, MySqlParserRETURNED_SQLSTATE, MySqlParserRETURNING, MySqlParserRETURNS, MySqlParserREUSE, MySqlParserROLE, MySqlParserROLLBACK, MySqlParserROLLUP, MySqlParserROTATE, MySqlParserROW, MySqlParserROWS, MySqlParserROW_FORMAT, MySqlParserRTREE, MySqlParserSAVEPOINT, MySqlParserSCHEDULE, MySqlParserSECURITY, MySqlParserSERVER, MySqlParserSESSION, MySqlParserSHARE, MySqlParserSHARED, MySqlParserSIGNED, MySqlParserSIMPLE, MySqlParserSLAVE, MySqlParserSLOW, MySqlParserSNAPSHOT, MySqlParserSOCKET, MySqlParserSOME, MySqlParserSONAME, MySqlParserSOUNDS, MySqlParserSOURCE, MySqlParserSQL_AFTER_GTIDS, MySqlParserSQL_AFTER_MTS_GAPS, MySqlParserSQL_BEFORE_GTIDS, MySqlParserSQL_BUFFER_RESULT, MySqlParserSQL_CACHE, MySqlParserSQL_NO_CACHE, MySqlParserSQL_THREAD, MySqlParserSTART, MySqlParserSTARTS, MySqlParserSTATS_AUTO_RECALC, MySqlParserSTATS_PERSISTENT, MySqlParserSTATS_SAMPLE_PAGES, MySqlParserSTATUS, MySqlParserSTOP, MySqlParserSTORAGE, MySqlParserSTRING, MySqlParserSUBCLASS_ORIGIN, MySqlParserSUBJECT, MySqlParserSUBPARTITION, MySqlParserSUBPARTITIONS, MySqlParserSUSPEND, MySqlParserSWAPS, MySqlParserSWITCHES, MySqlParserTABLE_NAME, MySqlParserTABLESPACE, MySqlParserTABLE_TYPE, MySqlParserTEMPORARY, MySqlParserTEMPTABLE, MySqlParserTHAN, MySqlParserTRADITIONAL, MySqlParserTRANSACTION, MySqlParserTRANSACTIONAL, MySqlParserTRIGGERS, MySqlParserTRUNCATE, MySqlParserUNBOUNDED, MySqlParserUNDEFINED, MySqlParserUNDOFILE, MySqlParserUNDO_BUFFER_SIZE, MySqlParserUNINSTALL, MySqlParserUNKNOWN, MySqlParserUNTIL, MySqlParserUPGRADE, MySqlParserUSER, MySqlParserUSE_FRM, MySqlParserUSER_RESOURCES, MySqlParserVALIDATION, MySqlParserVALUE, MySqlParserVARIABLES, MySqlParserVIEW, MySqlParserVIRTUAL, MySqlParserVISIBLE, MySqlParserWAIT, MySqlParserWARNINGS, MySqlParserWITHOUT, MySqlParserWORK, MySqlParserWRAPPER, MySqlParserX509, MySqlParserXA, MySqlParserXML, MySqlParserYES, MySqlParserEUR, MySqlParserUSA, MySqlParserJIS, MySqlParserISO, MySqlParserINTERNAL, MySqlParserQUARTER, MySqlParserMONTH, MySqlParserDAY, MySqlParserHOUR, MySqlParserMINUTE, MySqlParserWEEK, MySqlParserSECOND, MySqlParserMICROSECOND, MySqlParserADMIN, MySqlParserAUDIT_ABORT_EXEMPT, MySqlParserAUDIT_ADMIN, MySqlParserAUTHENTICATION_POLICY_ADMIN, MySqlParserBACKUP_ADMIN, MySqlParserBINLOG_ADMIN, MySqlParserBINLOG_ENCRYPTION_ADMIN, MySqlParserCLONE_ADMIN, MySqlParserCONNECTION_ADMIN, MySqlParserENCRYPTION_KEY_ADMIN, MySqlParserEXECUTE, MySqlParserFILE, MySqlParserFIREWALL_ADMIN, MySqlParserFIREWALL_EXEMPT, MySqlParserFIREWALL_USER, MySqlParserGROUP_REPLICATION_ADMIN, MySqlParserINNODB_REDO_LOG_ARCHIVE, MySqlParserINVOKE, MySqlParserLAMBDA, MySqlParserNDB_STORED_USER, MySqlParserPASSWORDLESS_USER_ADMIN, MySqlParserPERSIST_RO_VARIABLES_ADMIN, MySqlParserPRIVILEGES, MySqlParserPROCESS, MySqlParserRELOAD, MySqlParserREPLICATION_APPLIER, MySqlParserREPLICATION_SLAVE_ADMIN, MySqlParserRESOURCE_GROUP_ADMIN, MySqlParserRESOURCE_GROUP_USER, MySqlParserROLE_ADMIN, MySqlParserROUTINE, MySqlParserS3, MySqlParserSESSION_VARIABLES_ADMIN, MySqlParserSET_USER_ID, MySqlParserSHOW_ROUTINE, MySqlParserSHUTDOWN, MySqlParserSUPER, MySqlParserSYSTEM_VARIABLES_ADMIN, MySqlParserTABLES, MySqlParserTABLE_ENCRYPTION_ADMIN, MySqlParserVERSION_TOKEN_ADMIN, MySqlParserXA_RECOVER_ADMIN, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserARCHIVE, MySqlParserBLACKHOLE, MySqlParserCSV, MySqlParserFEDERATED, MySqlParserINNODB, MySqlParserMEMORY, MySqlParserMRG_MYISAM, MySqlParserMYISAM, MySqlParserNDB, MySqlParserNDBCLUSTER, MySqlParserPERFORMANCE_SCHEMA, MySqlParserTOKUDB, MySqlParserREPEATABLE, MySqlParserCOMMITTED, MySqlParserUNCOMMITTED, MySqlParserSERIALIZABLE, MySqlParserGEOMETRYCOLLECTION, MySqlParserLINESTRING, MySqlParserMULTILINESTRING, MySqlParserMULTIPOINT, MySqlParserMULTIPOLYGON, MySqlParserPOINT, MySqlParserPOLYGON, MySqlParserABS, MySqlParserACOS, MySqlParserADDDATE, MySqlParserADDTIME, MySqlParserAES_DECRYPT, MySqlParserAES_ENCRYPT, MySqlParserAREA, MySqlParserASBINARY, MySqlParserASIN, MySqlParserASTEXT, MySqlParserASWKB, MySqlParserASWKT, MySqlParserASYMMETRIC_DECRYPT, MySqlParserASYMMETRIC_DERIVE, MySqlParserASYMMETRIC_ENCRYPT, MySqlParserASYMMETRIC_SIGN, MySqlParserASYMMETRIC_VERIFY, MySqlParserATAN, MySqlParserATAN2, MySqlParserBENCHMARK, MySqlParserBIN, MySqlParserBIT_COUNT, MySqlParserBIT_LENGTH, MySqlParserBUFFER, MySqlParserCATALOG_NAME, MySqlParserCEIL, MySqlParserCEILING, MySqlParserCENTROID, MySqlParserCHARACTER_LENGTH, MySqlParserCHARSET, MySqlParserCHAR_LENGTH, MySqlParserCOERCIBILITY, MySqlParserCOLLATION, MySqlParserCOMPRESS, MySqlParserCONCAT, MySqlParserCONCAT_WS, MySqlParserCONNECTION_ID, MySqlParserCONV, MySqlParserCONVERT_TZ, MySqlParserCOS, MySqlParserCOT, MySqlParserCRC32, MySqlParserCREATE_ASYMMETRIC_PRIV_KEY, MySqlParserCREATE_ASYMMETRIC_PUB_KEY, MySqlParserCREATE_DH_PARAMETERS, MySqlParserCREATE_DIGEST, MySqlParserCROSSES, MySqlParserDATEDIFF, MySqlParserDATE_FORMAT, MySqlParserDAYNAME, MySqlParserDAYOFMONTH, MySqlParserDAYOFWEEK, MySqlParserDAYOFYEAR, MySqlParserDECODE, MySqlParserDEGREES, MySqlParserDES_DECRYPT, MySqlParserDES_ENCRYPT, MySqlParserDIMENSION, MySqlParserDISJOINT, MySqlParserDISTANCE, MySqlParserELT, MySqlParserENCODE, MySqlParserENCRYPT, MySqlParserENDPOINT, MySqlParserENGINE_ATTRIBUTE, MySqlParserENVELOPE, MySqlParserEQUALS, MySqlParserEXP, MySqlParserEXPORT_SET, MySqlParserEXTERIORRING, MySqlParserEXTRACTVALUE, MySqlParserFIELD, MySqlParserFIND_IN_SET, MySqlParserFLOOR, MySqlParserFORMAT, MySqlParserFOUND_ROWS, MySqlParserFROM_BASE64, MySqlParserFROM_DAYS, MySqlParserFROM_UNIXTIME, MySqlParserGEOMCOLLFROMTEXT, MySqlParserGEOMCOLLFROMWKB, MySqlParserGEOMETRYCOLLECTIONFROMTEXT, MySqlParserGEOMETRYCOLLECTIONFROMWKB, MySqlParserGEOMETRYFROMTEXT, MySqlParserGEOMETRYFROMWKB, MySqlParserGEOMETRYN, MySqlParserGEOMETRYTYPE, MySqlParserGEOMFROMTEXT, MySqlParserGEOMFROMWKB, MySqlParserGET_FORMAT, MySqlParserGET_LOCK, MySqlParserGLENGTH, MySqlParserGREATEST, MySqlParserGTID_SUBSET, MySqlParserGTID_SUBTRACT, MySqlParserHEX, MySqlParserIFNULL, MySqlParserINET6_ATON, MySqlParserINET6_NTOA, MySqlParserINET_ATON, MySqlParserINET_NTOA, MySqlParserINSTR, MySqlParserINTERIORRINGN, MySqlParserINTERSECTS, MySqlParserISCLOSED, MySqlParserISEMPTY, MySqlParserISNULL, MySqlParserISSIMPLE, MySqlParserIS_FREE_LOCK, MySqlParserIS_IPV4, MySqlParserIS_IPV4_COMPAT, MySqlParserIS_IPV4_MAPPED, MySqlParserIS_IPV6, MySqlParserIS_USED_LOCK, MySqlParserLAST_INSERT_ID, MySqlParserLCASE, MySqlParserLEAST, MySqlParserLENGTH, MySqlParserLINEFROMTEXT, MySqlParserLINEFROMWKB, MySqlParserLINESTRINGFROMTEXT, MySqlParserLINESTRINGFROMWKB, MySqlParserLN, MySqlParserLOAD_FILE, MySqlParserLOCATE, MySqlParserLOG, MySqlParserLOG10, MySqlParserLOG2, MySqlParserLOWER, MySqlParserLPAD, MySqlParserLTRIM, MySqlParserMAKEDATE, MySqlParserMAKETIME, MySqlParserMAKE_SET, MySqlParserMASTER_POS_WAIT, MySqlParserMBRCONTAINS, MySqlParserMBRDISJOINT, MySqlParserMBREQUAL, MySqlParserMBRINTERSECTS, MySqlParserMBROVERLAPS, MySqlParserMBRTOUCHES, MySqlParserMBRWITHIN, MySqlParserMD5, MySqlParserMLINEFROMTEXT, MySqlParserMLINEFROMWKB, MySqlParserMONTHNAME, MySqlParserMPOINTFROMTEXT, MySqlParserMPOINTFROMWKB, MySqlParserMPOLYFROMTEXT, MySqlParserMPOLYFROMWKB, MySqlParserMULTILINESTRINGFROMTEXT, MySqlParserMULTILINESTRINGFROMWKB, MySqlParserMULTIPOINTFROMTEXT, MySqlParserMULTIPOINTFROMWKB, MySqlParserMULTIPOLYGONFROMTEXT, MySqlParserMULTIPOLYGONFROMWKB, MySqlParserNAME_CONST, MySqlParserNULLIF, MySqlParserNUMGEOMETRIES, MySqlParserNUMINTERIORRINGS, MySqlParserNUMPOINTS, MySqlParserOCT, MySqlParserOCTET_LENGTH, MySqlParserORD, MySqlParserOVERLAPS, MySqlParserPERIOD_ADD, MySqlParserPERIOD_DIFF, MySqlParserPI, MySqlParserPOINTFROMTEXT, MySqlParserPOINTFROMWKB, MySqlParserPOINTN, MySqlParserPOLYFROMTEXT, MySqlParserPOLYFROMWKB, MySqlParserPOLYGONFROMTEXT, MySqlParserPOLYGONFROMWKB, MySqlParserPOW, MySqlParserPOWER, MySqlParserQUOTE, MySqlParserRADIANS, MySqlParserRAND, MySqlParserRANDOM, MySqlParserRANDOM_BYTES, MySqlParserRELEASE_LOCK, MySqlParserREVERSE, MySqlParserROUND, MySqlParserROW_COUNT, MySqlParserRPAD, MySqlParserRTRIM, MySqlParserSEC_TO_TIME, MySqlParserSECONDARY_ENGINE_ATTRIBUTE, MySqlParserSESSION_USER, MySqlParserSHA, MySqlParserSHA1, MySqlParserSHA2, MySqlParserSCHEMA_NAME, MySqlParserSIGN, MySqlParserSIN, MySqlParserSLEEP, MySqlParserSOUNDEX, MySqlParserSQL_THREAD_WAIT_AFTER_GTIDS, MySqlParserSQRT, MySqlParserSRID, MySqlParserSTARTPOINT, MySqlParserSTRCMP, MySqlParserSTR_TO_DATE, MySqlParserST_AREA, MySqlParserST_ASBINARY, MySqlParserST_ASTEXT, MySqlParserST_ASWKB, MySqlParserST_ASWKT, MySqlParserST_BUFFER, MySqlParserST_CENTROID, MySqlParserST_CONTAINS, MySqlParserST_CROSSES, MySqlParserST_DIFFERENCE, MySqlParserST_DIMENSION, MySqlParserST_DISJOINT, MySqlParserST_DISTANCE, MySqlParserST_ENDPOINT, MySqlParserST_ENVELOPE, MySqlParserST_EQUALS, MySqlParserST_EXTERIORRING, MySqlParserST_GEOMCOLLFROMTEXT, MySqlParserST_GEOMCOLLFROMTXT, MySqlParserST_GEOMCOLLFROMWKB, MySqlParserST_GEOMETRYCOLLECTIONFROMTEXT, MySqlParserST_GEOMETRYCOLLECTIONFROMWKB, MySqlParserST_GEOMETRYFROMTEXT, MySqlParserST_GEOMETRYFROMWKB, MySqlParserST_GEOMETRYN, MySqlParserST_GEOMETRYTYPE, MySqlParserST_GEOMFROMTEXT, MySqlParserST_GEOMFROMWKB, MySqlParserST_INTERIORRINGN, MySqlParserST_INTERSECTION, MySqlParserST_INTERSECTS, MySqlParserST_ISCLOSED, MySqlParserST_ISEMPTY, MySqlParserST_ISSIMPLE, MySqlParserST_LINEFROMTEXT, MySqlParserST_LINEFROMWKB, MySqlParserST_LINESTRINGFROMTEXT, MySqlParserST_LINESTRINGFROMWKB, MySqlParserST_NUMGEOMETRIES, MySqlParserST_NUMINTERIORRING, MySqlParserST_NUMINTERIORRINGS, MySqlParserST_NUMPOINTS, MySqlParserST_OVERLAPS, MySqlParserST_POINTFROMTEXT, MySqlParserST_POINTFROMWKB, MySqlParserST_POINTN, MySqlParserST_POLYFROMTEXT, MySqlParserST_POLYFROMWKB, MySqlParserST_POLYGONFROMTEXT, MySqlParserST_POLYGONFROMWKB, MySqlParserST_SRID, MySqlParserST_STARTPOINT, MySqlParserST_SYMDIFFERENCE, MySqlParserST_TOUCHES, MySqlParserST_UNION, MySqlParserST_WITHIN, MySqlParserST_X, MySqlParserST_Y, MySqlParserSTRING_TO_VECTOR, MySqlParserSUBDATE, MySqlParserSUBSTRING_INDEX, MySqlParserSUBTIME, MySqlParserSYSTEM_USER, MySqlParserTAN, MySqlParserTIMEDIFF, MySqlParserTIMESTAMPADD, MySqlParserTIMESTAMPDIFF, MySqlParserTIME_FORMAT, MySqlParserTIME_TO_SEC, MySqlParserTOUCHES, MySqlParserTO_BASE64, MySqlParserTO_DAYS, MySqlParserTO_SECONDS, MySqlParserTP_CONNECTION_ADMIN, MySqlParserUCASE, MySqlParserUNCOMPRESS, MySqlParserUNCOMPRESSED_LENGTH, MySqlParserUNHEX, MySqlParserUNIX_TIMESTAMP, MySqlParserUPDATEXML, MySqlParserUPPER, MySqlParserUUID, MySqlParserUUID_SHORT, MySqlParserVALIDATE_PASSWORD_STRENGTH, MySqlParserVECTOR_DIM, MySqlParserVECTOR_TO_STRING, MySqlParserVERSION, MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS, MySqlParserWEEKDAY, MySqlParserWEEKOFYEAR, MySqlParserWEIGHT_STRING, MySqlParserWITHIN, MySqlParserYEARWEEK, MySqlParserY_FUNCTION, MySqlParserX_FUNCTION, MySqlParserMOD, MySqlParserCHARSET_REVERSE_QOUTE_STRING, MySqlParserSTRING_LITERAL, MySqlParserID: + { + p.SetState(2910) + p.UidList() + } + + case MySqlParserALL: + { + p.SetState(2911) + p.Match(MySqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(2914) + p.Match(MySqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserTRUNCATE: + localctx = NewAlterByTruncatePartitionContext(p, localctx) + p.EnterOuterAlt(localctx, 5) + { + p.SetState(2915) + p.Match(MySqlParserTRUNCATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2916) + p.Match(MySqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2919) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserARRAY, MySqlParserATTRIBUTE, MySqlParserBUCKETS, MySqlParserCONDITION, MySqlParserCURRENT, MySqlParserCURRENT_USER, MySqlParserDATABASE, MySqlParserDEFAULT, MySqlParserDIAGNOSTICS, MySqlParserEMPTY, MySqlParserENFORCED, MySqlParserEXCEPT, MySqlParserGROUP, MySqlParserIF, MySqlParserIGNORED, MySqlParserINSERT, MySqlParserLATERAL, MySqlParserLEFT, MySqlParserNUMBER, MySqlParserOPTIONAL, MySqlParserORDER, MySqlParserPRIMARY, MySqlParserREPEAT, MySqlParserREPLACE, MySqlParserRIGHT, MySqlParserSCHEMA, MySqlParserSKIP_QUERY_REWRITE, MySqlParserSTACKED, MySqlParserSTATEMENT, MySqlParserDATE, MySqlParserTIME, MySqlParserTIMESTAMP, MySqlParserDATETIME, MySqlParserYEAR, MySqlParserBINARY, MySqlParserTEXT, MySqlParserENUM, MySqlParserSERIAL, MySqlParserJSON_ARRAY, MySqlParserJSON_ARRAYAGG, MySqlParserJSON_ARRAY_APPEND, MySqlParserJSON_ARRAY_INSERT, MySqlParserJSON_CONTAINS, MySqlParserJSON_CONTAINS_PATH, MySqlParserJSON_DEPTH, MySqlParserJSON_EXTRACT, MySqlParserJSON_INSERT, MySqlParserJSON_KEYS, MySqlParserJSON_LENGTH, MySqlParserJSON_MERGE, MySqlParserJSON_MERGE_PATCH, MySqlParserJSON_MERGE_PRESERVE, MySqlParserJSON_OBJECT, MySqlParserJSON_OBJECTAGG, MySqlParserJSON_OVERLAPS, MySqlParserJSON_PRETTY, MySqlParserJSON_QUOTE, MySqlParserJSON_REMOVE, MySqlParserJSON_REPLACE, MySqlParserJSON_SCHEMA_VALID, MySqlParserJSON_SCHEMA_VALIDATION_REPORT, MySqlParserJSON_SEARCH, MySqlParserJSON_SET, MySqlParserJSON_STORAGE_FREE, MySqlParserJSON_STORAGE_SIZE, MySqlParserJSON_TABLE, MySqlParserJSON_TYPE, MySqlParserJSON_UNQUOTE, MySqlParserJSON_VALID, MySqlParserJSON_VALUE, MySqlParserNESTED, MySqlParserORDINALITY, MySqlParserPATH, MySqlParserAVG, MySqlParserBIT_AND, MySqlParserBIT_OR, MySqlParserBIT_XOR, MySqlParserCOUNT, MySqlParserCUME_DIST, MySqlParserDENSE_RANK, MySqlParserFIRST_VALUE, MySqlParserGROUP_CONCAT, MySqlParserLAG, MySqlParserLAST_VALUE, MySqlParserLEAD, MySqlParserMAX, MySqlParserMIN, MySqlParserNTILE, MySqlParserNTH_VALUE, MySqlParserPERCENT_RANK, MySqlParserRANK, MySqlParserROW_NUMBER, MySqlParserSTD, MySqlParserSTDDEV, MySqlParserSTDDEV_POP, MySqlParserSTDDEV_SAMP, MySqlParserSUM, MySqlParserVAR_POP, MySqlParserVAR_SAMP, MySqlParserVARIANCE, MySqlParserCURRENT_DATE, MySqlParserCURRENT_TIME, MySqlParserCURRENT_TIMESTAMP, MySqlParserLOCALTIME, MySqlParserCURDATE, MySqlParserCURTIME, MySqlParserDATE_ADD, MySqlParserDATE_SUB, MySqlParserLOCALTIMESTAMP, MySqlParserNOW, MySqlParserPOSITION, MySqlParserSUBSTR, MySqlParserSUBSTRING, MySqlParserSYSDATE, MySqlParserTRIM, MySqlParserUTC_DATE, MySqlParserUTC_TIME, MySqlParserUTC_TIMESTAMP, MySqlParserACCOUNT, MySqlParserACTION, MySqlParserAFTER, MySqlParserAGGREGATE, MySqlParserALGORITHM, MySqlParserANY, MySqlParserAT, MySqlParserAUTHORS, MySqlParserAUTOCOMMIT, MySqlParserAUTOEXTEND_SIZE, MySqlParserAUTO_INCREMENT, MySqlParserAVG_ROW_LENGTH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserBIT, MySqlParserBLOCK, MySqlParserBOOL, MySqlParserBOOLEAN, MySqlParserBTREE, MySqlParserCACHE, MySqlParserCASCADED, MySqlParserCHAIN, MySqlParserCHANGED, MySqlParserCHANNEL, MySqlParserCHECKSUM, MySqlParserPAGE_CHECKSUM, MySqlParserCIPHER, MySqlParserCLASS_ORIGIN, MySqlParserCLIENT, MySqlParserCLOSE, MySqlParserCLUSTERING, MySqlParserCOALESCE, MySqlParserCODE, MySqlParserCOLUMNS, MySqlParserCOLUMN_FORMAT, MySqlParserCOLUMN_NAME, MySqlParserCOMMENT, MySqlParserCOMMIT, MySqlParserCOMPACT, MySqlParserCOMPLETION, MySqlParserCOMPRESSED, MySqlParserCOMPRESSION, MySqlParserCONCURRENT, MySqlParserCONNECT, MySqlParserCONNECTION, MySqlParserCONSISTENT, MySqlParserCONSTRAINT_CATALOG, MySqlParserCONSTRAINT_SCHEMA, MySqlParserCONSTRAINT_NAME, MySqlParserCONTAINS, MySqlParserCONTEXT, MySqlParserCONTRIBUTORS, MySqlParserCOPY, MySqlParserCPU, MySqlParserCURSOR_NAME, MySqlParserDATA, MySqlParserDATAFILE, MySqlParserDEALLOCATE, MySqlParserDEFAULT_AUTH, MySqlParserDEFINER, MySqlParserDELAY_KEY_WRITE, MySqlParserDES_KEY_FILE, MySqlParserDIRECTORY, MySqlParserDISABLE, MySqlParserDISCARD, MySqlParserDISK, MySqlParserDO, MySqlParserDUMPFILE, MySqlParserDUPLICATE, MySqlParserDYNAMIC, MySqlParserENABLE, MySqlParserENCRYPTION, MySqlParserEND, MySqlParserENDS, MySqlParserENGINE, MySqlParserENGINES, MySqlParserERROR, MySqlParserERRORS, MySqlParserESCAPE, MySqlParserEVEN, MySqlParserEVENT, MySqlParserEVENTS, MySqlParserEVERY, MySqlParserEXCHANGE, MySqlParserEXCLUSIVE, MySqlParserEXPIRE, MySqlParserEXPORT, MySqlParserEXTENDED, MySqlParserEXTENT_SIZE, MySqlParserFAILED_LOGIN_ATTEMPTS, MySqlParserFAST, MySqlParserFAULTS, MySqlParserFIELDS, MySqlParserFILE_BLOCK_SIZE, MySqlParserFILTER, MySqlParserFIRST, MySqlParserFIXED, MySqlParserFLUSH, MySqlParserFOLLOWS, MySqlParserFOUND, MySqlParserFULL, MySqlParserFUNCTION, MySqlParserGENERAL, MySqlParserGLOBAL, MySqlParserGRANTS, MySqlParserGROUP_REPLICATION, MySqlParserHANDLER, MySqlParserHASH, MySqlParserHELP, MySqlParserHISTORY, MySqlParserHOST, MySqlParserHOSTS, MySqlParserIDENTIFIED, MySqlParserIGNORE_SERVER_IDS, MySqlParserIMPORT, MySqlParserINDEXES, MySqlParserINITIAL_SIZE, MySqlParserINPLACE, MySqlParserINSERT_METHOD, MySqlParserINSTALL, MySqlParserINSTANCE, MySqlParserINSTANT, MySqlParserINVISIBLE, MySqlParserINVOKER, MySqlParserIO, MySqlParserIO_THREAD, MySqlParserIPC, MySqlParserISOLATION, MySqlParserISSUER, MySqlParserJSON, MySqlParserKEY_BLOCK_SIZE, MySqlParserLANGUAGE, MySqlParserLAST, MySqlParserLEAVES, MySqlParserLESS, MySqlParserLEVEL, MySqlParserLIST, MySqlParserLOCAL, MySqlParserLOGFILE, MySqlParserLOGS, MySqlParserMASTER, MySqlParserMASTER_AUTO_POSITION, MySqlParserMASTER_CONNECT_RETRY, MySqlParserMASTER_DELAY, MySqlParserMASTER_HEARTBEAT_PERIOD, MySqlParserMASTER_HOST, MySqlParserMASTER_LOG_FILE, MySqlParserMASTER_LOG_POS, MySqlParserMASTER_PASSWORD, MySqlParserMASTER_PORT, MySqlParserMASTER_RETRY_COUNT, MySqlParserMASTER_SSL, MySqlParserMASTER_SSL_CA, MySqlParserMASTER_SSL_CAPATH, MySqlParserMASTER_SSL_CERT, MySqlParserMASTER_SSL_CIPHER, MySqlParserMASTER_SSL_CRL, MySqlParserMASTER_SSL_CRLPATH, MySqlParserMASTER_SSL_KEY, MySqlParserMASTER_TLS_VERSION, MySqlParserMASTER_USER, MySqlParserMAX_CONNECTIONS_PER_HOUR, MySqlParserMAX_QUERIES_PER_HOUR, MySqlParserMAX_ROWS, MySqlParserMAX_SIZE, MySqlParserMAX_UPDATES_PER_HOUR, MySqlParserMAX_USER_CONNECTIONS, MySqlParserMEDIUM, MySqlParserMEMBER, MySqlParserMERGE, MySqlParserMESSAGE_TEXT, MySqlParserMID, MySqlParserMIGRATE, MySqlParserMIN_ROWS, MySqlParserMODE, MySqlParserMODIFY, MySqlParserMUTEX, MySqlParserMYSQL, MySqlParserMYSQL_ERRNO, MySqlParserNAME, MySqlParserNAMES, MySqlParserNCHAR, MySqlParserNEVER, MySqlParserNEXT, MySqlParserNO, MySqlParserNOCOPY, MySqlParserNOWAIT, MySqlParserNODEGROUP, MySqlParserNONE, MySqlParserODBC, MySqlParserOFFLINE, MySqlParserOFFSET, MySqlParserOF, MySqlParserOJ, MySqlParserOLD_PASSWORD, MySqlParserONE, MySqlParserONLINE, MySqlParserONLY, MySqlParserOPEN, MySqlParserOPTIMIZER_COSTS, MySqlParserOPTIONS, MySqlParserOWNER, MySqlParserPACK_KEYS, MySqlParserPAGE, MySqlParserPARSER, MySqlParserPARTIAL, MySqlParserPARTITIONING, MySqlParserPARTITIONS, MySqlParserPASSWORD, MySqlParserPASSWORD_LOCK_TIME, MySqlParserPHASE, MySqlParserPLUGIN, MySqlParserPLUGIN_DIR, MySqlParserPLUGINS, MySqlParserPORT, MySqlParserPRECEDES, MySqlParserPREPARE, MySqlParserPRESERVE, MySqlParserPREV, MySqlParserPROCESSLIST, MySqlParserPROFILE, MySqlParserPROFILES, MySqlParserPROXY, MySqlParserQUERY, MySqlParserQUICK, MySqlParserREBUILD, MySqlParserRECOVER, MySqlParserRECURSIVE, MySqlParserREDO_BUFFER_SIZE, MySqlParserREDUNDANT, MySqlParserRELAY, MySqlParserRELAY_LOG_FILE, MySqlParserRELAY_LOG_POS, MySqlParserRELAYLOG, MySqlParserREMOVE, MySqlParserREORGANIZE, MySqlParserREPAIR, MySqlParserREPLICATE_DO_DB, MySqlParserREPLICATE_DO_TABLE, MySqlParserREPLICATE_IGNORE_DB, MySqlParserREPLICATE_IGNORE_TABLE, MySqlParserREPLICATE_REWRITE_DB, MySqlParserREPLICATE_WILD_DO_TABLE, MySqlParserREPLICATE_WILD_IGNORE_TABLE, MySqlParserREPLICATION, MySqlParserRESET, MySqlParserRESUME, MySqlParserRETURNED_SQLSTATE, MySqlParserRETURNING, MySqlParserRETURNS, MySqlParserREUSE, MySqlParserROLE, MySqlParserROLLBACK, MySqlParserROLLUP, MySqlParserROTATE, MySqlParserROW, MySqlParserROWS, MySqlParserROW_FORMAT, MySqlParserRTREE, MySqlParserSAVEPOINT, MySqlParserSCHEDULE, MySqlParserSECURITY, MySqlParserSERVER, MySqlParserSESSION, MySqlParserSHARE, MySqlParserSHARED, MySqlParserSIGNED, MySqlParserSIMPLE, MySqlParserSLAVE, MySqlParserSLOW, MySqlParserSNAPSHOT, MySqlParserSOCKET, MySqlParserSOME, MySqlParserSONAME, MySqlParserSOUNDS, MySqlParserSOURCE, MySqlParserSQL_AFTER_GTIDS, MySqlParserSQL_AFTER_MTS_GAPS, MySqlParserSQL_BEFORE_GTIDS, MySqlParserSQL_BUFFER_RESULT, MySqlParserSQL_CACHE, MySqlParserSQL_NO_CACHE, MySqlParserSQL_THREAD, MySqlParserSTART, MySqlParserSTARTS, MySqlParserSTATS_AUTO_RECALC, MySqlParserSTATS_PERSISTENT, MySqlParserSTATS_SAMPLE_PAGES, MySqlParserSTATUS, MySqlParserSTOP, MySqlParserSTORAGE, MySqlParserSTRING, MySqlParserSUBCLASS_ORIGIN, MySqlParserSUBJECT, MySqlParserSUBPARTITION, MySqlParserSUBPARTITIONS, MySqlParserSUSPEND, MySqlParserSWAPS, MySqlParserSWITCHES, MySqlParserTABLE_NAME, MySqlParserTABLESPACE, MySqlParserTABLE_TYPE, MySqlParserTEMPORARY, MySqlParserTEMPTABLE, MySqlParserTHAN, MySqlParserTRADITIONAL, MySqlParserTRANSACTION, MySqlParserTRANSACTIONAL, MySqlParserTRIGGERS, MySqlParserTRUNCATE, MySqlParserUNBOUNDED, MySqlParserUNDEFINED, MySqlParserUNDOFILE, MySqlParserUNDO_BUFFER_SIZE, MySqlParserUNINSTALL, MySqlParserUNKNOWN, MySqlParserUNTIL, MySqlParserUPGRADE, MySqlParserUSER, MySqlParserUSE_FRM, MySqlParserUSER_RESOURCES, MySqlParserVALIDATION, MySqlParserVALUE, MySqlParserVARIABLES, MySqlParserVIEW, MySqlParserVIRTUAL, MySqlParserVISIBLE, MySqlParserWAIT, MySqlParserWARNINGS, MySqlParserWITHOUT, MySqlParserWORK, MySqlParserWRAPPER, MySqlParserX509, MySqlParserXA, MySqlParserXML, MySqlParserYES, MySqlParserEUR, MySqlParserUSA, MySqlParserJIS, MySqlParserISO, MySqlParserINTERNAL, MySqlParserQUARTER, MySqlParserMONTH, MySqlParserDAY, MySqlParserHOUR, MySqlParserMINUTE, MySqlParserWEEK, MySqlParserSECOND, MySqlParserMICROSECOND, MySqlParserADMIN, MySqlParserAUDIT_ABORT_EXEMPT, MySqlParserAUDIT_ADMIN, MySqlParserAUTHENTICATION_POLICY_ADMIN, MySqlParserBACKUP_ADMIN, MySqlParserBINLOG_ADMIN, MySqlParserBINLOG_ENCRYPTION_ADMIN, MySqlParserCLONE_ADMIN, MySqlParserCONNECTION_ADMIN, MySqlParserENCRYPTION_KEY_ADMIN, MySqlParserEXECUTE, MySqlParserFILE, MySqlParserFIREWALL_ADMIN, MySqlParserFIREWALL_EXEMPT, MySqlParserFIREWALL_USER, MySqlParserGROUP_REPLICATION_ADMIN, MySqlParserINNODB_REDO_LOG_ARCHIVE, MySqlParserINVOKE, MySqlParserLAMBDA, MySqlParserNDB_STORED_USER, MySqlParserPASSWORDLESS_USER_ADMIN, MySqlParserPERSIST_RO_VARIABLES_ADMIN, MySqlParserPRIVILEGES, MySqlParserPROCESS, MySqlParserRELOAD, MySqlParserREPLICATION_APPLIER, MySqlParserREPLICATION_SLAVE_ADMIN, MySqlParserRESOURCE_GROUP_ADMIN, MySqlParserRESOURCE_GROUP_USER, MySqlParserROLE_ADMIN, MySqlParserROUTINE, MySqlParserS3, MySqlParserSESSION_VARIABLES_ADMIN, MySqlParserSET_USER_ID, MySqlParserSHOW_ROUTINE, MySqlParserSHUTDOWN, MySqlParserSUPER, MySqlParserSYSTEM_VARIABLES_ADMIN, MySqlParserTABLES, MySqlParserTABLE_ENCRYPTION_ADMIN, MySqlParserVERSION_TOKEN_ADMIN, MySqlParserXA_RECOVER_ADMIN, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserARCHIVE, MySqlParserBLACKHOLE, MySqlParserCSV, MySqlParserFEDERATED, MySqlParserINNODB, MySqlParserMEMORY, MySqlParserMRG_MYISAM, MySqlParserMYISAM, MySqlParserNDB, MySqlParserNDBCLUSTER, MySqlParserPERFORMANCE_SCHEMA, MySqlParserTOKUDB, MySqlParserREPEATABLE, MySqlParserCOMMITTED, MySqlParserUNCOMMITTED, MySqlParserSERIALIZABLE, MySqlParserGEOMETRYCOLLECTION, MySqlParserLINESTRING, MySqlParserMULTILINESTRING, MySqlParserMULTIPOINT, MySqlParserMULTIPOLYGON, MySqlParserPOINT, MySqlParserPOLYGON, MySqlParserABS, MySqlParserACOS, MySqlParserADDDATE, MySqlParserADDTIME, MySqlParserAES_DECRYPT, MySqlParserAES_ENCRYPT, MySqlParserAREA, MySqlParserASBINARY, MySqlParserASIN, MySqlParserASTEXT, MySqlParserASWKB, MySqlParserASWKT, MySqlParserASYMMETRIC_DECRYPT, MySqlParserASYMMETRIC_DERIVE, MySqlParserASYMMETRIC_ENCRYPT, MySqlParserASYMMETRIC_SIGN, MySqlParserASYMMETRIC_VERIFY, MySqlParserATAN, MySqlParserATAN2, MySqlParserBENCHMARK, MySqlParserBIN, MySqlParserBIT_COUNT, MySqlParserBIT_LENGTH, MySqlParserBUFFER, MySqlParserCATALOG_NAME, MySqlParserCEIL, MySqlParserCEILING, MySqlParserCENTROID, MySqlParserCHARACTER_LENGTH, MySqlParserCHARSET, MySqlParserCHAR_LENGTH, MySqlParserCOERCIBILITY, MySqlParserCOLLATION, MySqlParserCOMPRESS, MySqlParserCONCAT, MySqlParserCONCAT_WS, MySqlParserCONNECTION_ID, MySqlParserCONV, MySqlParserCONVERT_TZ, MySqlParserCOS, MySqlParserCOT, MySqlParserCRC32, MySqlParserCREATE_ASYMMETRIC_PRIV_KEY, MySqlParserCREATE_ASYMMETRIC_PUB_KEY, MySqlParserCREATE_DH_PARAMETERS, MySqlParserCREATE_DIGEST, MySqlParserCROSSES, MySqlParserDATEDIFF, MySqlParserDATE_FORMAT, MySqlParserDAYNAME, MySqlParserDAYOFMONTH, MySqlParserDAYOFWEEK, MySqlParserDAYOFYEAR, MySqlParserDECODE, MySqlParserDEGREES, MySqlParserDES_DECRYPT, MySqlParserDES_ENCRYPT, MySqlParserDIMENSION, MySqlParserDISJOINT, MySqlParserDISTANCE, MySqlParserELT, MySqlParserENCODE, MySqlParserENCRYPT, MySqlParserENDPOINT, MySqlParserENGINE_ATTRIBUTE, MySqlParserENVELOPE, MySqlParserEQUALS, MySqlParserEXP, MySqlParserEXPORT_SET, MySqlParserEXTERIORRING, MySqlParserEXTRACTVALUE, MySqlParserFIELD, MySqlParserFIND_IN_SET, MySqlParserFLOOR, MySqlParserFORMAT, MySqlParserFOUND_ROWS, MySqlParserFROM_BASE64, MySqlParserFROM_DAYS, MySqlParserFROM_UNIXTIME, MySqlParserGEOMCOLLFROMTEXT, MySqlParserGEOMCOLLFROMWKB, MySqlParserGEOMETRYCOLLECTIONFROMTEXT, MySqlParserGEOMETRYCOLLECTIONFROMWKB, MySqlParserGEOMETRYFROMTEXT, MySqlParserGEOMETRYFROMWKB, MySqlParserGEOMETRYN, MySqlParserGEOMETRYTYPE, MySqlParserGEOMFROMTEXT, MySqlParserGEOMFROMWKB, MySqlParserGET_FORMAT, MySqlParserGET_LOCK, MySqlParserGLENGTH, MySqlParserGREATEST, MySqlParserGTID_SUBSET, MySqlParserGTID_SUBTRACT, MySqlParserHEX, MySqlParserIFNULL, MySqlParserINET6_ATON, MySqlParserINET6_NTOA, MySqlParserINET_ATON, MySqlParserINET_NTOA, MySqlParserINSTR, MySqlParserINTERIORRINGN, MySqlParserINTERSECTS, MySqlParserISCLOSED, MySqlParserISEMPTY, MySqlParserISNULL, MySqlParserISSIMPLE, MySqlParserIS_FREE_LOCK, MySqlParserIS_IPV4, MySqlParserIS_IPV4_COMPAT, MySqlParserIS_IPV4_MAPPED, MySqlParserIS_IPV6, MySqlParserIS_USED_LOCK, MySqlParserLAST_INSERT_ID, MySqlParserLCASE, MySqlParserLEAST, MySqlParserLENGTH, MySqlParserLINEFROMTEXT, MySqlParserLINEFROMWKB, MySqlParserLINESTRINGFROMTEXT, MySqlParserLINESTRINGFROMWKB, MySqlParserLN, MySqlParserLOAD_FILE, MySqlParserLOCATE, MySqlParserLOG, MySqlParserLOG10, MySqlParserLOG2, MySqlParserLOWER, MySqlParserLPAD, MySqlParserLTRIM, MySqlParserMAKEDATE, MySqlParserMAKETIME, MySqlParserMAKE_SET, MySqlParserMASTER_POS_WAIT, MySqlParserMBRCONTAINS, MySqlParserMBRDISJOINT, MySqlParserMBREQUAL, MySqlParserMBRINTERSECTS, MySqlParserMBROVERLAPS, MySqlParserMBRTOUCHES, MySqlParserMBRWITHIN, MySqlParserMD5, MySqlParserMLINEFROMTEXT, MySqlParserMLINEFROMWKB, MySqlParserMONTHNAME, MySqlParserMPOINTFROMTEXT, MySqlParserMPOINTFROMWKB, MySqlParserMPOLYFROMTEXT, MySqlParserMPOLYFROMWKB, MySqlParserMULTILINESTRINGFROMTEXT, MySqlParserMULTILINESTRINGFROMWKB, MySqlParserMULTIPOINTFROMTEXT, MySqlParserMULTIPOINTFROMWKB, MySqlParserMULTIPOLYGONFROMTEXT, MySqlParserMULTIPOLYGONFROMWKB, MySqlParserNAME_CONST, MySqlParserNULLIF, MySqlParserNUMGEOMETRIES, MySqlParserNUMINTERIORRINGS, MySqlParserNUMPOINTS, MySqlParserOCT, MySqlParserOCTET_LENGTH, MySqlParserORD, MySqlParserOVERLAPS, MySqlParserPERIOD_ADD, MySqlParserPERIOD_DIFF, MySqlParserPI, MySqlParserPOINTFROMTEXT, MySqlParserPOINTFROMWKB, MySqlParserPOINTN, MySqlParserPOLYFROMTEXT, MySqlParserPOLYFROMWKB, MySqlParserPOLYGONFROMTEXT, MySqlParserPOLYGONFROMWKB, MySqlParserPOW, MySqlParserPOWER, MySqlParserQUOTE, MySqlParserRADIANS, MySqlParserRAND, MySqlParserRANDOM, MySqlParserRANDOM_BYTES, MySqlParserRELEASE_LOCK, MySqlParserREVERSE, MySqlParserROUND, MySqlParserROW_COUNT, MySqlParserRPAD, MySqlParserRTRIM, MySqlParserSEC_TO_TIME, MySqlParserSECONDARY_ENGINE_ATTRIBUTE, MySqlParserSESSION_USER, MySqlParserSHA, MySqlParserSHA1, MySqlParserSHA2, MySqlParserSCHEMA_NAME, MySqlParserSIGN, MySqlParserSIN, MySqlParserSLEEP, MySqlParserSOUNDEX, MySqlParserSQL_THREAD_WAIT_AFTER_GTIDS, MySqlParserSQRT, MySqlParserSRID, MySqlParserSTARTPOINT, MySqlParserSTRCMP, MySqlParserSTR_TO_DATE, MySqlParserST_AREA, MySqlParserST_ASBINARY, MySqlParserST_ASTEXT, MySqlParserST_ASWKB, MySqlParserST_ASWKT, MySqlParserST_BUFFER, MySqlParserST_CENTROID, MySqlParserST_CONTAINS, MySqlParserST_CROSSES, MySqlParserST_DIFFERENCE, MySqlParserST_DIMENSION, MySqlParserST_DISJOINT, MySqlParserST_DISTANCE, MySqlParserST_ENDPOINT, MySqlParserST_ENVELOPE, MySqlParserST_EQUALS, MySqlParserST_EXTERIORRING, MySqlParserST_GEOMCOLLFROMTEXT, MySqlParserST_GEOMCOLLFROMTXT, MySqlParserST_GEOMCOLLFROMWKB, MySqlParserST_GEOMETRYCOLLECTIONFROMTEXT, MySqlParserST_GEOMETRYCOLLECTIONFROMWKB, MySqlParserST_GEOMETRYFROMTEXT, MySqlParserST_GEOMETRYFROMWKB, MySqlParserST_GEOMETRYN, MySqlParserST_GEOMETRYTYPE, MySqlParserST_GEOMFROMTEXT, MySqlParserST_GEOMFROMWKB, MySqlParserST_INTERIORRINGN, MySqlParserST_INTERSECTION, MySqlParserST_INTERSECTS, MySqlParserST_ISCLOSED, MySqlParserST_ISEMPTY, MySqlParserST_ISSIMPLE, MySqlParserST_LINEFROMTEXT, MySqlParserST_LINEFROMWKB, MySqlParserST_LINESTRINGFROMTEXT, MySqlParserST_LINESTRINGFROMWKB, MySqlParserST_NUMGEOMETRIES, MySqlParserST_NUMINTERIORRING, MySqlParserST_NUMINTERIORRINGS, MySqlParserST_NUMPOINTS, MySqlParserST_OVERLAPS, MySqlParserST_POINTFROMTEXT, MySqlParserST_POINTFROMWKB, MySqlParserST_POINTN, MySqlParserST_POLYFROMTEXT, MySqlParserST_POLYFROMWKB, MySqlParserST_POLYGONFROMTEXT, MySqlParserST_POLYGONFROMWKB, MySqlParserST_SRID, MySqlParserST_STARTPOINT, MySqlParserST_SYMDIFFERENCE, MySqlParserST_TOUCHES, MySqlParserST_UNION, MySqlParserST_WITHIN, MySqlParserST_X, MySqlParserST_Y, MySqlParserSTRING_TO_VECTOR, MySqlParserSUBDATE, MySqlParserSUBSTRING_INDEX, MySqlParserSUBTIME, MySqlParserSYSTEM_USER, MySqlParserTAN, MySqlParserTIMEDIFF, MySqlParserTIMESTAMPADD, MySqlParserTIMESTAMPDIFF, MySqlParserTIME_FORMAT, MySqlParserTIME_TO_SEC, MySqlParserTOUCHES, MySqlParserTO_BASE64, MySqlParserTO_DAYS, MySqlParserTO_SECONDS, MySqlParserTP_CONNECTION_ADMIN, MySqlParserUCASE, MySqlParserUNCOMPRESS, MySqlParserUNCOMPRESSED_LENGTH, MySqlParserUNHEX, MySqlParserUNIX_TIMESTAMP, MySqlParserUPDATEXML, MySqlParserUPPER, MySqlParserUUID, MySqlParserUUID_SHORT, MySqlParserVALIDATE_PASSWORD_STRENGTH, MySqlParserVECTOR_DIM, MySqlParserVECTOR_TO_STRING, MySqlParserVERSION, MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS, MySqlParserWEEKDAY, MySqlParserWEEKOFYEAR, MySqlParserWEIGHT_STRING, MySqlParserWITHIN, MySqlParserYEARWEEK, MySqlParserY_FUNCTION, MySqlParserX_FUNCTION, MySqlParserMOD, MySqlParserCHARSET_REVERSE_QOUTE_STRING, MySqlParserSTRING_LITERAL, MySqlParserID: + { + p.SetState(2917) + p.UidList() + } + + case MySqlParserALL: + { + p.SetState(2918) + p.Match(MySqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case MySqlParserCOALESCE: + localctx = NewAlterByCoalescePartitionContext(p, localctx) + p.EnterOuterAlt(localctx, 6) + { + p.SetState(2921) + p.Match(MySqlParserCOALESCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2922) + p.Match(MySqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2923) + p.DecimalLiteral() + } + + case MySqlParserREORGANIZE: + localctx = NewAlterByReorganizePartitionContext(p, localctx) + p.EnterOuterAlt(localctx, 7) + { + p.SetState(2924) + p.Match(MySqlParserREORGANIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2925) + p.Match(MySqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2926) + p.UidList() + } + { + p.SetState(2927) + p.Match(MySqlParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2928) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2929) + p.PartitionDefinition() + } + p.SetState(2934) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(2930) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2931) + p.PartitionDefinition() + } + + p.SetState(2936) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2937) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserEXCHANGE: + localctx = NewAlterByExchangePartitionContext(p, localctx) + p.EnterOuterAlt(localctx, 8) + { + p.SetState(2939) + p.Match(MySqlParserEXCHANGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2940) + p.Match(MySqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2941) + p.Uid() + } + { + p.SetState(2942) + p.Match(MySqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2943) + p.Match(MySqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2944) + p.TableName() + } + p.SetState(2947) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 376, p.GetParserRuleContext()) == 1 { + { + p.SetState(2945) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*AlterByExchangePartitionContext).validationFormat = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserWITH || _la == MySqlParserWITHOUT) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*AlterByExchangePartitionContext).validationFormat = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2946) + p.Match(MySqlParserVALIDATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case MySqlParserANALYZE: + localctx = NewAlterByAnalyzePartitionContext(p, localctx) + p.EnterOuterAlt(localctx, 9) + { + p.SetState(2949) + p.Match(MySqlParserANALYZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2950) + p.Match(MySqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2953) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserARRAY, MySqlParserATTRIBUTE, MySqlParserBUCKETS, MySqlParserCONDITION, MySqlParserCURRENT, MySqlParserCURRENT_USER, MySqlParserDATABASE, MySqlParserDEFAULT, MySqlParserDIAGNOSTICS, MySqlParserEMPTY, MySqlParserENFORCED, MySqlParserEXCEPT, MySqlParserGROUP, MySqlParserIF, MySqlParserIGNORED, MySqlParserINSERT, MySqlParserLATERAL, MySqlParserLEFT, MySqlParserNUMBER, MySqlParserOPTIONAL, MySqlParserORDER, MySqlParserPRIMARY, MySqlParserREPEAT, MySqlParserREPLACE, MySqlParserRIGHT, MySqlParserSCHEMA, MySqlParserSKIP_QUERY_REWRITE, MySqlParserSTACKED, MySqlParserSTATEMENT, MySqlParserDATE, MySqlParserTIME, MySqlParserTIMESTAMP, MySqlParserDATETIME, MySqlParserYEAR, MySqlParserBINARY, MySqlParserTEXT, MySqlParserENUM, MySqlParserSERIAL, MySqlParserJSON_ARRAY, MySqlParserJSON_ARRAYAGG, MySqlParserJSON_ARRAY_APPEND, MySqlParserJSON_ARRAY_INSERT, MySqlParserJSON_CONTAINS, MySqlParserJSON_CONTAINS_PATH, MySqlParserJSON_DEPTH, MySqlParserJSON_EXTRACT, MySqlParserJSON_INSERT, MySqlParserJSON_KEYS, MySqlParserJSON_LENGTH, MySqlParserJSON_MERGE, MySqlParserJSON_MERGE_PATCH, MySqlParserJSON_MERGE_PRESERVE, MySqlParserJSON_OBJECT, MySqlParserJSON_OBJECTAGG, MySqlParserJSON_OVERLAPS, MySqlParserJSON_PRETTY, MySqlParserJSON_QUOTE, MySqlParserJSON_REMOVE, MySqlParserJSON_REPLACE, MySqlParserJSON_SCHEMA_VALID, MySqlParserJSON_SCHEMA_VALIDATION_REPORT, MySqlParserJSON_SEARCH, MySqlParserJSON_SET, MySqlParserJSON_STORAGE_FREE, MySqlParserJSON_STORAGE_SIZE, MySqlParserJSON_TABLE, MySqlParserJSON_TYPE, MySqlParserJSON_UNQUOTE, MySqlParserJSON_VALID, MySqlParserJSON_VALUE, MySqlParserNESTED, MySqlParserORDINALITY, MySqlParserPATH, MySqlParserAVG, MySqlParserBIT_AND, MySqlParserBIT_OR, MySqlParserBIT_XOR, MySqlParserCOUNT, MySqlParserCUME_DIST, MySqlParserDENSE_RANK, MySqlParserFIRST_VALUE, MySqlParserGROUP_CONCAT, MySqlParserLAG, MySqlParserLAST_VALUE, MySqlParserLEAD, MySqlParserMAX, MySqlParserMIN, MySqlParserNTILE, MySqlParserNTH_VALUE, MySqlParserPERCENT_RANK, MySqlParserRANK, MySqlParserROW_NUMBER, MySqlParserSTD, MySqlParserSTDDEV, MySqlParserSTDDEV_POP, MySqlParserSTDDEV_SAMP, MySqlParserSUM, MySqlParserVAR_POP, MySqlParserVAR_SAMP, MySqlParserVARIANCE, MySqlParserCURRENT_DATE, MySqlParserCURRENT_TIME, MySqlParserCURRENT_TIMESTAMP, MySqlParserLOCALTIME, MySqlParserCURDATE, MySqlParserCURTIME, MySqlParserDATE_ADD, MySqlParserDATE_SUB, MySqlParserLOCALTIMESTAMP, MySqlParserNOW, MySqlParserPOSITION, MySqlParserSUBSTR, MySqlParserSUBSTRING, MySqlParserSYSDATE, MySqlParserTRIM, MySqlParserUTC_DATE, MySqlParserUTC_TIME, MySqlParserUTC_TIMESTAMP, MySqlParserACCOUNT, MySqlParserACTION, MySqlParserAFTER, MySqlParserAGGREGATE, MySqlParserALGORITHM, MySqlParserANY, MySqlParserAT, MySqlParserAUTHORS, MySqlParserAUTOCOMMIT, MySqlParserAUTOEXTEND_SIZE, MySqlParserAUTO_INCREMENT, MySqlParserAVG_ROW_LENGTH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserBIT, MySqlParserBLOCK, MySqlParserBOOL, MySqlParserBOOLEAN, MySqlParserBTREE, MySqlParserCACHE, MySqlParserCASCADED, MySqlParserCHAIN, MySqlParserCHANGED, MySqlParserCHANNEL, MySqlParserCHECKSUM, MySqlParserPAGE_CHECKSUM, MySqlParserCIPHER, MySqlParserCLASS_ORIGIN, MySqlParserCLIENT, MySqlParserCLOSE, MySqlParserCLUSTERING, MySqlParserCOALESCE, MySqlParserCODE, MySqlParserCOLUMNS, MySqlParserCOLUMN_FORMAT, MySqlParserCOLUMN_NAME, MySqlParserCOMMENT, MySqlParserCOMMIT, MySqlParserCOMPACT, MySqlParserCOMPLETION, MySqlParserCOMPRESSED, MySqlParserCOMPRESSION, MySqlParserCONCURRENT, MySqlParserCONNECT, MySqlParserCONNECTION, MySqlParserCONSISTENT, MySqlParserCONSTRAINT_CATALOG, MySqlParserCONSTRAINT_SCHEMA, MySqlParserCONSTRAINT_NAME, MySqlParserCONTAINS, MySqlParserCONTEXT, MySqlParserCONTRIBUTORS, MySqlParserCOPY, MySqlParserCPU, MySqlParserCURSOR_NAME, MySqlParserDATA, MySqlParserDATAFILE, MySqlParserDEALLOCATE, MySqlParserDEFAULT_AUTH, MySqlParserDEFINER, MySqlParserDELAY_KEY_WRITE, MySqlParserDES_KEY_FILE, MySqlParserDIRECTORY, MySqlParserDISABLE, MySqlParserDISCARD, MySqlParserDISK, MySqlParserDO, MySqlParserDUMPFILE, MySqlParserDUPLICATE, MySqlParserDYNAMIC, MySqlParserENABLE, MySqlParserENCRYPTION, MySqlParserEND, MySqlParserENDS, MySqlParserENGINE, MySqlParserENGINES, MySqlParserERROR, MySqlParserERRORS, MySqlParserESCAPE, MySqlParserEVEN, MySqlParserEVENT, MySqlParserEVENTS, MySqlParserEVERY, MySqlParserEXCHANGE, MySqlParserEXCLUSIVE, MySqlParserEXPIRE, MySqlParserEXPORT, MySqlParserEXTENDED, MySqlParserEXTENT_SIZE, MySqlParserFAILED_LOGIN_ATTEMPTS, MySqlParserFAST, MySqlParserFAULTS, MySqlParserFIELDS, MySqlParserFILE_BLOCK_SIZE, MySqlParserFILTER, MySqlParserFIRST, MySqlParserFIXED, MySqlParserFLUSH, MySqlParserFOLLOWS, MySqlParserFOUND, MySqlParserFULL, MySqlParserFUNCTION, MySqlParserGENERAL, MySqlParserGLOBAL, MySqlParserGRANTS, MySqlParserGROUP_REPLICATION, MySqlParserHANDLER, MySqlParserHASH, MySqlParserHELP, MySqlParserHISTORY, MySqlParserHOST, MySqlParserHOSTS, MySqlParserIDENTIFIED, MySqlParserIGNORE_SERVER_IDS, MySqlParserIMPORT, MySqlParserINDEXES, MySqlParserINITIAL_SIZE, MySqlParserINPLACE, MySqlParserINSERT_METHOD, MySqlParserINSTALL, MySqlParserINSTANCE, MySqlParserINSTANT, MySqlParserINVISIBLE, MySqlParserINVOKER, MySqlParserIO, MySqlParserIO_THREAD, MySqlParserIPC, MySqlParserISOLATION, MySqlParserISSUER, MySqlParserJSON, MySqlParserKEY_BLOCK_SIZE, MySqlParserLANGUAGE, MySqlParserLAST, MySqlParserLEAVES, MySqlParserLESS, MySqlParserLEVEL, MySqlParserLIST, MySqlParserLOCAL, MySqlParserLOGFILE, MySqlParserLOGS, MySqlParserMASTER, MySqlParserMASTER_AUTO_POSITION, MySqlParserMASTER_CONNECT_RETRY, MySqlParserMASTER_DELAY, MySqlParserMASTER_HEARTBEAT_PERIOD, MySqlParserMASTER_HOST, MySqlParserMASTER_LOG_FILE, MySqlParserMASTER_LOG_POS, MySqlParserMASTER_PASSWORD, MySqlParserMASTER_PORT, MySqlParserMASTER_RETRY_COUNT, MySqlParserMASTER_SSL, MySqlParserMASTER_SSL_CA, MySqlParserMASTER_SSL_CAPATH, MySqlParserMASTER_SSL_CERT, MySqlParserMASTER_SSL_CIPHER, MySqlParserMASTER_SSL_CRL, MySqlParserMASTER_SSL_CRLPATH, MySqlParserMASTER_SSL_KEY, MySqlParserMASTER_TLS_VERSION, MySqlParserMASTER_USER, MySqlParserMAX_CONNECTIONS_PER_HOUR, MySqlParserMAX_QUERIES_PER_HOUR, MySqlParserMAX_ROWS, MySqlParserMAX_SIZE, MySqlParserMAX_UPDATES_PER_HOUR, MySqlParserMAX_USER_CONNECTIONS, MySqlParserMEDIUM, MySqlParserMEMBER, MySqlParserMERGE, MySqlParserMESSAGE_TEXT, MySqlParserMID, MySqlParserMIGRATE, MySqlParserMIN_ROWS, MySqlParserMODE, MySqlParserMODIFY, MySqlParserMUTEX, MySqlParserMYSQL, MySqlParserMYSQL_ERRNO, MySqlParserNAME, MySqlParserNAMES, MySqlParserNCHAR, MySqlParserNEVER, MySqlParserNEXT, MySqlParserNO, MySqlParserNOCOPY, MySqlParserNOWAIT, MySqlParserNODEGROUP, MySqlParserNONE, MySqlParserODBC, MySqlParserOFFLINE, MySqlParserOFFSET, MySqlParserOF, MySqlParserOJ, MySqlParserOLD_PASSWORD, MySqlParserONE, MySqlParserONLINE, MySqlParserONLY, MySqlParserOPEN, MySqlParserOPTIMIZER_COSTS, MySqlParserOPTIONS, MySqlParserOWNER, MySqlParserPACK_KEYS, MySqlParserPAGE, MySqlParserPARSER, MySqlParserPARTIAL, MySqlParserPARTITIONING, MySqlParserPARTITIONS, MySqlParserPASSWORD, MySqlParserPASSWORD_LOCK_TIME, MySqlParserPHASE, MySqlParserPLUGIN, MySqlParserPLUGIN_DIR, MySqlParserPLUGINS, MySqlParserPORT, MySqlParserPRECEDES, MySqlParserPREPARE, MySqlParserPRESERVE, MySqlParserPREV, MySqlParserPROCESSLIST, MySqlParserPROFILE, MySqlParserPROFILES, MySqlParserPROXY, MySqlParserQUERY, MySqlParserQUICK, MySqlParserREBUILD, MySqlParserRECOVER, MySqlParserRECURSIVE, MySqlParserREDO_BUFFER_SIZE, MySqlParserREDUNDANT, MySqlParserRELAY, MySqlParserRELAY_LOG_FILE, MySqlParserRELAY_LOG_POS, MySqlParserRELAYLOG, MySqlParserREMOVE, MySqlParserREORGANIZE, MySqlParserREPAIR, MySqlParserREPLICATE_DO_DB, MySqlParserREPLICATE_DO_TABLE, MySqlParserREPLICATE_IGNORE_DB, MySqlParserREPLICATE_IGNORE_TABLE, MySqlParserREPLICATE_REWRITE_DB, MySqlParserREPLICATE_WILD_DO_TABLE, MySqlParserREPLICATE_WILD_IGNORE_TABLE, MySqlParserREPLICATION, MySqlParserRESET, MySqlParserRESUME, MySqlParserRETURNED_SQLSTATE, MySqlParserRETURNING, MySqlParserRETURNS, MySqlParserREUSE, MySqlParserROLE, MySqlParserROLLBACK, MySqlParserROLLUP, MySqlParserROTATE, MySqlParserROW, MySqlParserROWS, MySqlParserROW_FORMAT, MySqlParserRTREE, MySqlParserSAVEPOINT, MySqlParserSCHEDULE, MySqlParserSECURITY, MySqlParserSERVER, MySqlParserSESSION, MySqlParserSHARE, MySqlParserSHARED, MySqlParserSIGNED, MySqlParserSIMPLE, MySqlParserSLAVE, MySqlParserSLOW, MySqlParserSNAPSHOT, MySqlParserSOCKET, MySqlParserSOME, MySqlParserSONAME, MySqlParserSOUNDS, MySqlParserSOURCE, MySqlParserSQL_AFTER_GTIDS, MySqlParserSQL_AFTER_MTS_GAPS, MySqlParserSQL_BEFORE_GTIDS, MySqlParserSQL_BUFFER_RESULT, MySqlParserSQL_CACHE, MySqlParserSQL_NO_CACHE, MySqlParserSQL_THREAD, MySqlParserSTART, MySqlParserSTARTS, MySqlParserSTATS_AUTO_RECALC, MySqlParserSTATS_PERSISTENT, MySqlParserSTATS_SAMPLE_PAGES, MySqlParserSTATUS, MySqlParserSTOP, MySqlParserSTORAGE, MySqlParserSTRING, MySqlParserSUBCLASS_ORIGIN, MySqlParserSUBJECT, MySqlParserSUBPARTITION, MySqlParserSUBPARTITIONS, MySqlParserSUSPEND, MySqlParserSWAPS, MySqlParserSWITCHES, MySqlParserTABLE_NAME, MySqlParserTABLESPACE, MySqlParserTABLE_TYPE, MySqlParserTEMPORARY, MySqlParserTEMPTABLE, MySqlParserTHAN, MySqlParserTRADITIONAL, MySqlParserTRANSACTION, MySqlParserTRANSACTIONAL, MySqlParserTRIGGERS, MySqlParserTRUNCATE, MySqlParserUNBOUNDED, MySqlParserUNDEFINED, MySqlParserUNDOFILE, MySqlParserUNDO_BUFFER_SIZE, MySqlParserUNINSTALL, MySqlParserUNKNOWN, MySqlParserUNTIL, MySqlParserUPGRADE, MySqlParserUSER, MySqlParserUSE_FRM, MySqlParserUSER_RESOURCES, MySqlParserVALIDATION, MySqlParserVALUE, MySqlParserVARIABLES, MySqlParserVIEW, MySqlParserVIRTUAL, MySqlParserVISIBLE, MySqlParserWAIT, MySqlParserWARNINGS, MySqlParserWITHOUT, MySqlParserWORK, MySqlParserWRAPPER, MySqlParserX509, MySqlParserXA, MySqlParserXML, MySqlParserYES, MySqlParserEUR, MySqlParserUSA, MySqlParserJIS, MySqlParserISO, MySqlParserINTERNAL, MySqlParserQUARTER, MySqlParserMONTH, MySqlParserDAY, MySqlParserHOUR, MySqlParserMINUTE, MySqlParserWEEK, MySqlParserSECOND, MySqlParserMICROSECOND, MySqlParserADMIN, MySqlParserAUDIT_ABORT_EXEMPT, MySqlParserAUDIT_ADMIN, MySqlParserAUTHENTICATION_POLICY_ADMIN, MySqlParserBACKUP_ADMIN, MySqlParserBINLOG_ADMIN, MySqlParserBINLOG_ENCRYPTION_ADMIN, MySqlParserCLONE_ADMIN, MySqlParserCONNECTION_ADMIN, MySqlParserENCRYPTION_KEY_ADMIN, MySqlParserEXECUTE, MySqlParserFILE, MySqlParserFIREWALL_ADMIN, MySqlParserFIREWALL_EXEMPT, MySqlParserFIREWALL_USER, MySqlParserGROUP_REPLICATION_ADMIN, MySqlParserINNODB_REDO_LOG_ARCHIVE, MySqlParserINVOKE, MySqlParserLAMBDA, MySqlParserNDB_STORED_USER, MySqlParserPASSWORDLESS_USER_ADMIN, MySqlParserPERSIST_RO_VARIABLES_ADMIN, MySqlParserPRIVILEGES, MySqlParserPROCESS, MySqlParserRELOAD, MySqlParserREPLICATION_APPLIER, MySqlParserREPLICATION_SLAVE_ADMIN, MySqlParserRESOURCE_GROUP_ADMIN, MySqlParserRESOURCE_GROUP_USER, MySqlParserROLE_ADMIN, MySqlParserROUTINE, MySqlParserS3, MySqlParserSESSION_VARIABLES_ADMIN, MySqlParserSET_USER_ID, MySqlParserSHOW_ROUTINE, MySqlParserSHUTDOWN, MySqlParserSUPER, MySqlParserSYSTEM_VARIABLES_ADMIN, MySqlParserTABLES, MySqlParserTABLE_ENCRYPTION_ADMIN, MySqlParserVERSION_TOKEN_ADMIN, MySqlParserXA_RECOVER_ADMIN, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserARCHIVE, MySqlParserBLACKHOLE, MySqlParserCSV, MySqlParserFEDERATED, MySqlParserINNODB, MySqlParserMEMORY, MySqlParserMRG_MYISAM, MySqlParserMYISAM, MySqlParserNDB, MySqlParserNDBCLUSTER, MySqlParserPERFORMANCE_SCHEMA, MySqlParserTOKUDB, MySqlParserREPEATABLE, MySqlParserCOMMITTED, MySqlParserUNCOMMITTED, MySqlParserSERIALIZABLE, MySqlParserGEOMETRYCOLLECTION, MySqlParserLINESTRING, MySqlParserMULTILINESTRING, MySqlParserMULTIPOINT, MySqlParserMULTIPOLYGON, MySqlParserPOINT, MySqlParserPOLYGON, MySqlParserABS, MySqlParserACOS, MySqlParserADDDATE, MySqlParserADDTIME, MySqlParserAES_DECRYPT, MySqlParserAES_ENCRYPT, MySqlParserAREA, MySqlParserASBINARY, MySqlParserASIN, MySqlParserASTEXT, MySqlParserASWKB, MySqlParserASWKT, MySqlParserASYMMETRIC_DECRYPT, MySqlParserASYMMETRIC_DERIVE, MySqlParserASYMMETRIC_ENCRYPT, MySqlParserASYMMETRIC_SIGN, MySqlParserASYMMETRIC_VERIFY, MySqlParserATAN, MySqlParserATAN2, MySqlParserBENCHMARK, MySqlParserBIN, MySqlParserBIT_COUNT, MySqlParserBIT_LENGTH, MySqlParserBUFFER, MySqlParserCATALOG_NAME, MySqlParserCEIL, MySqlParserCEILING, MySqlParserCENTROID, MySqlParserCHARACTER_LENGTH, MySqlParserCHARSET, MySqlParserCHAR_LENGTH, MySqlParserCOERCIBILITY, MySqlParserCOLLATION, MySqlParserCOMPRESS, MySqlParserCONCAT, MySqlParserCONCAT_WS, MySqlParserCONNECTION_ID, MySqlParserCONV, MySqlParserCONVERT_TZ, MySqlParserCOS, MySqlParserCOT, MySqlParserCRC32, MySqlParserCREATE_ASYMMETRIC_PRIV_KEY, MySqlParserCREATE_ASYMMETRIC_PUB_KEY, MySqlParserCREATE_DH_PARAMETERS, MySqlParserCREATE_DIGEST, MySqlParserCROSSES, MySqlParserDATEDIFF, MySqlParserDATE_FORMAT, MySqlParserDAYNAME, MySqlParserDAYOFMONTH, MySqlParserDAYOFWEEK, MySqlParserDAYOFYEAR, MySqlParserDECODE, MySqlParserDEGREES, MySqlParserDES_DECRYPT, MySqlParserDES_ENCRYPT, MySqlParserDIMENSION, MySqlParserDISJOINT, MySqlParserDISTANCE, MySqlParserELT, MySqlParserENCODE, MySqlParserENCRYPT, MySqlParserENDPOINT, MySqlParserENGINE_ATTRIBUTE, MySqlParserENVELOPE, MySqlParserEQUALS, MySqlParserEXP, MySqlParserEXPORT_SET, MySqlParserEXTERIORRING, MySqlParserEXTRACTVALUE, MySqlParserFIELD, MySqlParserFIND_IN_SET, MySqlParserFLOOR, MySqlParserFORMAT, MySqlParserFOUND_ROWS, MySqlParserFROM_BASE64, MySqlParserFROM_DAYS, MySqlParserFROM_UNIXTIME, MySqlParserGEOMCOLLFROMTEXT, MySqlParserGEOMCOLLFROMWKB, MySqlParserGEOMETRYCOLLECTIONFROMTEXT, MySqlParserGEOMETRYCOLLECTIONFROMWKB, MySqlParserGEOMETRYFROMTEXT, MySqlParserGEOMETRYFROMWKB, MySqlParserGEOMETRYN, MySqlParserGEOMETRYTYPE, MySqlParserGEOMFROMTEXT, MySqlParserGEOMFROMWKB, MySqlParserGET_FORMAT, MySqlParserGET_LOCK, MySqlParserGLENGTH, MySqlParserGREATEST, MySqlParserGTID_SUBSET, MySqlParserGTID_SUBTRACT, MySqlParserHEX, MySqlParserIFNULL, MySqlParserINET6_ATON, MySqlParserINET6_NTOA, MySqlParserINET_ATON, MySqlParserINET_NTOA, MySqlParserINSTR, MySqlParserINTERIORRINGN, MySqlParserINTERSECTS, MySqlParserISCLOSED, MySqlParserISEMPTY, MySqlParserISNULL, MySqlParserISSIMPLE, MySqlParserIS_FREE_LOCK, MySqlParserIS_IPV4, MySqlParserIS_IPV4_COMPAT, MySqlParserIS_IPV4_MAPPED, MySqlParserIS_IPV6, MySqlParserIS_USED_LOCK, MySqlParserLAST_INSERT_ID, MySqlParserLCASE, MySqlParserLEAST, MySqlParserLENGTH, MySqlParserLINEFROMTEXT, MySqlParserLINEFROMWKB, MySqlParserLINESTRINGFROMTEXT, MySqlParserLINESTRINGFROMWKB, MySqlParserLN, MySqlParserLOAD_FILE, MySqlParserLOCATE, MySqlParserLOG, MySqlParserLOG10, MySqlParserLOG2, MySqlParserLOWER, MySqlParserLPAD, MySqlParserLTRIM, MySqlParserMAKEDATE, MySqlParserMAKETIME, MySqlParserMAKE_SET, MySqlParserMASTER_POS_WAIT, MySqlParserMBRCONTAINS, MySqlParserMBRDISJOINT, MySqlParserMBREQUAL, MySqlParserMBRINTERSECTS, MySqlParserMBROVERLAPS, MySqlParserMBRTOUCHES, MySqlParserMBRWITHIN, MySqlParserMD5, MySqlParserMLINEFROMTEXT, MySqlParserMLINEFROMWKB, MySqlParserMONTHNAME, MySqlParserMPOINTFROMTEXT, MySqlParserMPOINTFROMWKB, MySqlParserMPOLYFROMTEXT, MySqlParserMPOLYFROMWKB, MySqlParserMULTILINESTRINGFROMTEXT, MySqlParserMULTILINESTRINGFROMWKB, MySqlParserMULTIPOINTFROMTEXT, MySqlParserMULTIPOINTFROMWKB, MySqlParserMULTIPOLYGONFROMTEXT, MySqlParserMULTIPOLYGONFROMWKB, MySqlParserNAME_CONST, MySqlParserNULLIF, MySqlParserNUMGEOMETRIES, MySqlParserNUMINTERIORRINGS, MySqlParserNUMPOINTS, MySqlParserOCT, MySqlParserOCTET_LENGTH, MySqlParserORD, MySqlParserOVERLAPS, MySqlParserPERIOD_ADD, MySqlParserPERIOD_DIFF, MySqlParserPI, MySqlParserPOINTFROMTEXT, MySqlParserPOINTFROMWKB, MySqlParserPOINTN, MySqlParserPOLYFROMTEXT, MySqlParserPOLYFROMWKB, MySqlParserPOLYGONFROMTEXT, MySqlParserPOLYGONFROMWKB, MySqlParserPOW, MySqlParserPOWER, MySqlParserQUOTE, MySqlParserRADIANS, MySqlParserRAND, MySqlParserRANDOM, MySqlParserRANDOM_BYTES, MySqlParserRELEASE_LOCK, MySqlParserREVERSE, MySqlParserROUND, MySqlParserROW_COUNT, MySqlParserRPAD, MySqlParserRTRIM, MySqlParserSEC_TO_TIME, MySqlParserSECONDARY_ENGINE_ATTRIBUTE, MySqlParserSESSION_USER, MySqlParserSHA, MySqlParserSHA1, MySqlParserSHA2, MySqlParserSCHEMA_NAME, MySqlParserSIGN, MySqlParserSIN, MySqlParserSLEEP, MySqlParserSOUNDEX, MySqlParserSQL_THREAD_WAIT_AFTER_GTIDS, MySqlParserSQRT, MySqlParserSRID, MySqlParserSTARTPOINT, MySqlParserSTRCMP, MySqlParserSTR_TO_DATE, MySqlParserST_AREA, MySqlParserST_ASBINARY, MySqlParserST_ASTEXT, MySqlParserST_ASWKB, MySqlParserST_ASWKT, MySqlParserST_BUFFER, MySqlParserST_CENTROID, MySqlParserST_CONTAINS, MySqlParserST_CROSSES, MySqlParserST_DIFFERENCE, MySqlParserST_DIMENSION, MySqlParserST_DISJOINT, MySqlParserST_DISTANCE, MySqlParserST_ENDPOINT, MySqlParserST_ENVELOPE, MySqlParserST_EQUALS, MySqlParserST_EXTERIORRING, MySqlParserST_GEOMCOLLFROMTEXT, MySqlParserST_GEOMCOLLFROMTXT, MySqlParserST_GEOMCOLLFROMWKB, MySqlParserST_GEOMETRYCOLLECTIONFROMTEXT, MySqlParserST_GEOMETRYCOLLECTIONFROMWKB, MySqlParserST_GEOMETRYFROMTEXT, MySqlParserST_GEOMETRYFROMWKB, MySqlParserST_GEOMETRYN, MySqlParserST_GEOMETRYTYPE, MySqlParserST_GEOMFROMTEXT, MySqlParserST_GEOMFROMWKB, MySqlParserST_INTERIORRINGN, MySqlParserST_INTERSECTION, MySqlParserST_INTERSECTS, MySqlParserST_ISCLOSED, MySqlParserST_ISEMPTY, MySqlParserST_ISSIMPLE, MySqlParserST_LINEFROMTEXT, MySqlParserST_LINEFROMWKB, MySqlParserST_LINESTRINGFROMTEXT, MySqlParserST_LINESTRINGFROMWKB, MySqlParserST_NUMGEOMETRIES, MySqlParserST_NUMINTERIORRING, MySqlParserST_NUMINTERIORRINGS, MySqlParserST_NUMPOINTS, MySqlParserST_OVERLAPS, MySqlParserST_POINTFROMTEXT, MySqlParserST_POINTFROMWKB, MySqlParserST_POINTN, MySqlParserST_POLYFROMTEXT, MySqlParserST_POLYFROMWKB, MySqlParserST_POLYGONFROMTEXT, MySqlParserST_POLYGONFROMWKB, MySqlParserST_SRID, MySqlParserST_STARTPOINT, MySqlParserST_SYMDIFFERENCE, MySqlParserST_TOUCHES, MySqlParserST_UNION, MySqlParserST_WITHIN, MySqlParserST_X, MySqlParserST_Y, MySqlParserSTRING_TO_VECTOR, MySqlParserSUBDATE, MySqlParserSUBSTRING_INDEX, MySqlParserSUBTIME, MySqlParserSYSTEM_USER, MySqlParserTAN, MySqlParserTIMEDIFF, MySqlParserTIMESTAMPADD, MySqlParserTIMESTAMPDIFF, MySqlParserTIME_FORMAT, MySqlParserTIME_TO_SEC, MySqlParserTOUCHES, MySqlParserTO_BASE64, MySqlParserTO_DAYS, MySqlParserTO_SECONDS, MySqlParserTP_CONNECTION_ADMIN, MySqlParserUCASE, MySqlParserUNCOMPRESS, MySqlParserUNCOMPRESSED_LENGTH, MySqlParserUNHEX, MySqlParserUNIX_TIMESTAMP, MySqlParserUPDATEXML, MySqlParserUPPER, MySqlParserUUID, MySqlParserUUID_SHORT, MySqlParserVALIDATE_PASSWORD_STRENGTH, MySqlParserVECTOR_DIM, MySqlParserVECTOR_TO_STRING, MySqlParserVERSION, MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS, MySqlParserWEEKDAY, MySqlParserWEEKOFYEAR, MySqlParserWEIGHT_STRING, MySqlParserWITHIN, MySqlParserYEARWEEK, MySqlParserY_FUNCTION, MySqlParserX_FUNCTION, MySqlParserMOD, MySqlParserCHARSET_REVERSE_QOUTE_STRING, MySqlParserSTRING_LITERAL, MySqlParserID: + { + p.SetState(2951) + p.UidList() + } + + case MySqlParserALL: + { + p.SetState(2952) + p.Match(MySqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case MySqlParserCHECK: + localctx = NewAlterByCheckPartitionContext(p, localctx) + p.EnterOuterAlt(localctx, 10) + { + p.SetState(2955) + p.Match(MySqlParserCHECK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2956) + p.Match(MySqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2959) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserARRAY, MySqlParserATTRIBUTE, MySqlParserBUCKETS, MySqlParserCONDITION, MySqlParserCURRENT, MySqlParserCURRENT_USER, MySqlParserDATABASE, MySqlParserDEFAULT, MySqlParserDIAGNOSTICS, MySqlParserEMPTY, MySqlParserENFORCED, MySqlParserEXCEPT, MySqlParserGROUP, MySqlParserIF, MySqlParserIGNORED, MySqlParserINSERT, MySqlParserLATERAL, MySqlParserLEFT, MySqlParserNUMBER, MySqlParserOPTIONAL, MySqlParserORDER, MySqlParserPRIMARY, MySqlParserREPEAT, MySqlParserREPLACE, MySqlParserRIGHT, MySqlParserSCHEMA, MySqlParserSKIP_QUERY_REWRITE, MySqlParserSTACKED, MySqlParserSTATEMENT, MySqlParserDATE, MySqlParserTIME, MySqlParserTIMESTAMP, MySqlParserDATETIME, MySqlParserYEAR, MySqlParserBINARY, MySqlParserTEXT, MySqlParserENUM, MySqlParserSERIAL, MySqlParserJSON_ARRAY, MySqlParserJSON_ARRAYAGG, MySqlParserJSON_ARRAY_APPEND, MySqlParserJSON_ARRAY_INSERT, MySqlParserJSON_CONTAINS, MySqlParserJSON_CONTAINS_PATH, MySqlParserJSON_DEPTH, MySqlParserJSON_EXTRACT, MySqlParserJSON_INSERT, MySqlParserJSON_KEYS, MySqlParserJSON_LENGTH, MySqlParserJSON_MERGE, MySqlParserJSON_MERGE_PATCH, MySqlParserJSON_MERGE_PRESERVE, MySqlParserJSON_OBJECT, MySqlParserJSON_OBJECTAGG, MySqlParserJSON_OVERLAPS, MySqlParserJSON_PRETTY, MySqlParserJSON_QUOTE, MySqlParserJSON_REMOVE, MySqlParserJSON_REPLACE, MySqlParserJSON_SCHEMA_VALID, MySqlParserJSON_SCHEMA_VALIDATION_REPORT, MySqlParserJSON_SEARCH, MySqlParserJSON_SET, MySqlParserJSON_STORAGE_FREE, MySqlParserJSON_STORAGE_SIZE, MySqlParserJSON_TABLE, MySqlParserJSON_TYPE, MySqlParserJSON_UNQUOTE, MySqlParserJSON_VALID, MySqlParserJSON_VALUE, MySqlParserNESTED, MySqlParserORDINALITY, MySqlParserPATH, MySqlParserAVG, MySqlParserBIT_AND, MySqlParserBIT_OR, MySqlParserBIT_XOR, MySqlParserCOUNT, MySqlParserCUME_DIST, MySqlParserDENSE_RANK, MySqlParserFIRST_VALUE, MySqlParserGROUP_CONCAT, MySqlParserLAG, MySqlParserLAST_VALUE, MySqlParserLEAD, MySqlParserMAX, MySqlParserMIN, MySqlParserNTILE, MySqlParserNTH_VALUE, MySqlParserPERCENT_RANK, MySqlParserRANK, MySqlParserROW_NUMBER, MySqlParserSTD, MySqlParserSTDDEV, MySqlParserSTDDEV_POP, MySqlParserSTDDEV_SAMP, MySqlParserSUM, MySqlParserVAR_POP, MySqlParserVAR_SAMP, MySqlParserVARIANCE, MySqlParserCURRENT_DATE, MySqlParserCURRENT_TIME, MySqlParserCURRENT_TIMESTAMP, MySqlParserLOCALTIME, MySqlParserCURDATE, MySqlParserCURTIME, MySqlParserDATE_ADD, MySqlParserDATE_SUB, MySqlParserLOCALTIMESTAMP, MySqlParserNOW, MySqlParserPOSITION, MySqlParserSUBSTR, MySqlParserSUBSTRING, MySqlParserSYSDATE, MySqlParserTRIM, MySqlParserUTC_DATE, MySqlParserUTC_TIME, MySqlParserUTC_TIMESTAMP, MySqlParserACCOUNT, MySqlParserACTION, MySqlParserAFTER, MySqlParserAGGREGATE, MySqlParserALGORITHM, MySqlParserANY, MySqlParserAT, MySqlParserAUTHORS, MySqlParserAUTOCOMMIT, MySqlParserAUTOEXTEND_SIZE, MySqlParserAUTO_INCREMENT, MySqlParserAVG_ROW_LENGTH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserBIT, MySqlParserBLOCK, MySqlParserBOOL, MySqlParserBOOLEAN, MySqlParserBTREE, MySqlParserCACHE, MySqlParserCASCADED, MySqlParserCHAIN, MySqlParserCHANGED, MySqlParserCHANNEL, MySqlParserCHECKSUM, MySqlParserPAGE_CHECKSUM, MySqlParserCIPHER, MySqlParserCLASS_ORIGIN, MySqlParserCLIENT, MySqlParserCLOSE, MySqlParserCLUSTERING, MySqlParserCOALESCE, MySqlParserCODE, MySqlParserCOLUMNS, MySqlParserCOLUMN_FORMAT, MySqlParserCOLUMN_NAME, MySqlParserCOMMENT, MySqlParserCOMMIT, MySqlParserCOMPACT, MySqlParserCOMPLETION, MySqlParserCOMPRESSED, MySqlParserCOMPRESSION, MySqlParserCONCURRENT, MySqlParserCONNECT, MySqlParserCONNECTION, MySqlParserCONSISTENT, MySqlParserCONSTRAINT_CATALOG, MySqlParserCONSTRAINT_SCHEMA, MySqlParserCONSTRAINT_NAME, MySqlParserCONTAINS, MySqlParserCONTEXT, MySqlParserCONTRIBUTORS, MySqlParserCOPY, MySqlParserCPU, MySqlParserCURSOR_NAME, MySqlParserDATA, MySqlParserDATAFILE, MySqlParserDEALLOCATE, MySqlParserDEFAULT_AUTH, MySqlParserDEFINER, MySqlParserDELAY_KEY_WRITE, MySqlParserDES_KEY_FILE, MySqlParserDIRECTORY, MySqlParserDISABLE, MySqlParserDISCARD, MySqlParserDISK, MySqlParserDO, MySqlParserDUMPFILE, MySqlParserDUPLICATE, MySqlParserDYNAMIC, MySqlParserENABLE, MySqlParserENCRYPTION, MySqlParserEND, MySqlParserENDS, MySqlParserENGINE, MySqlParserENGINES, MySqlParserERROR, MySqlParserERRORS, MySqlParserESCAPE, MySqlParserEVEN, MySqlParserEVENT, MySqlParserEVENTS, MySqlParserEVERY, MySqlParserEXCHANGE, MySqlParserEXCLUSIVE, MySqlParserEXPIRE, MySqlParserEXPORT, MySqlParserEXTENDED, MySqlParserEXTENT_SIZE, MySqlParserFAILED_LOGIN_ATTEMPTS, MySqlParserFAST, MySqlParserFAULTS, MySqlParserFIELDS, MySqlParserFILE_BLOCK_SIZE, MySqlParserFILTER, MySqlParserFIRST, MySqlParserFIXED, MySqlParserFLUSH, MySqlParserFOLLOWS, MySqlParserFOUND, MySqlParserFULL, MySqlParserFUNCTION, MySqlParserGENERAL, MySqlParserGLOBAL, MySqlParserGRANTS, MySqlParserGROUP_REPLICATION, MySqlParserHANDLER, MySqlParserHASH, MySqlParserHELP, MySqlParserHISTORY, MySqlParserHOST, MySqlParserHOSTS, MySqlParserIDENTIFIED, MySqlParserIGNORE_SERVER_IDS, MySqlParserIMPORT, MySqlParserINDEXES, MySqlParserINITIAL_SIZE, MySqlParserINPLACE, MySqlParserINSERT_METHOD, MySqlParserINSTALL, MySqlParserINSTANCE, MySqlParserINSTANT, MySqlParserINVISIBLE, MySqlParserINVOKER, MySqlParserIO, MySqlParserIO_THREAD, MySqlParserIPC, MySqlParserISOLATION, MySqlParserISSUER, MySqlParserJSON, MySqlParserKEY_BLOCK_SIZE, MySqlParserLANGUAGE, MySqlParserLAST, MySqlParserLEAVES, MySqlParserLESS, MySqlParserLEVEL, MySqlParserLIST, MySqlParserLOCAL, MySqlParserLOGFILE, MySqlParserLOGS, MySqlParserMASTER, MySqlParserMASTER_AUTO_POSITION, MySqlParserMASTER_CONNECT_RETRY, MySqlParserMASTER_DELAY, MySqlParserMASTER_HEARTBEAT_PERIOD, MySqlParserMASTER_HOST, MySqlParserMASTER_LOG_FILE, MySqlParserMASTER_LOG_POS, MySqlParserMASTER_PASSWORD, MySqlParserMASTER_PORT, MySqlParserMASTER_RETRY_COUNT, MySqlParserMASTER_SSL, MySqlParserMASTER_SSL_CA, MySqlParserMASTER_SSL_CAPATH, MySqlParserMASTER_SSL_CERT, MySqlParserMASTER_SSL_CIPHER, MySqlParserMASTER_SSL_CRL, MySqlParserMASTER_SSL_CRLPATH, MySqlParserMASTER_SSL_KEY, MySqlParserMASTER_TLS_VERSION, MySqlParserMASTER_USER, MySqlParserMAX_CONNECTIONS_PER_HOUR, MySqlParserMAX_QUERIES_PER_HOUR, MySqlParserMAX_ROWS, MySqlParserMAX_SIZE, MySqlParserMAX_UPDATES_PER_HOUR, MySqlParserMAX_USER_CONNECTIONS, MySqlParserMEDIUM, MySqlParserMEMBER, MySqlParserMERGE, MySqlParserMESSAGE_TEXT, MySqlParserMID, MySqlParserMIGRATE, MySqlParserMIN_ROWS, MySqlParserMODE, MySqlParserMODIFY, MySqlParserMUTEX, MySqlParserMYSQL, MySqlParserMYSQL_ERRNO, MySqlParserNAME, MySqlParserNAMES, MySqlParserNCHAR, MySqlParserNEVER, MySqlParserNEXT, MySqlParserNO, MySqlParserNOCOPY, MySqlParserNOWAIT, MySqlParserNODEGROUP, MySqlParserNONE, MySqlParserODBC, MySqlParserOFFLINE, MySqlParserOFFSET, MySqlParserOF, MySqlParserOJ, MySqlParserOLD_PASSWORD, MySqlParserONE, MySqlParserONLINE, MySqlParserONLY, MySqlParserOPEN, MySqlParserOPTIMIZER_COSTS, MySqlParserOPTIONS, MySqlParserOWNER, MySqlParserPACK_KEYS, MySqlParserPAGE, MySqlParserPARSER, MySqlParserPARTIAL, MySqlParserPARTITIONING, MySqlParserPARTITIONS, MySqlParserPASSWORD, MySqlParserPASSWORD_LOCK_TIME, MySqlParserPHASE, MySqlParserPLUGIN, MySqlParserPLUGIN_DIR, MySqlParserPLUGINS, MySqlParserPORT, MySqlParserPRECEDES, MySqlParserPREPARE, MySqlParserPRESERVE, MySqlParserPREV, MySqlParserPROCESSLIST, MySqlParserPROFILE, MySqlParserPROFILES, MySqlParserPROXY, MySqlParserQUERY, MySqlParserQUICK, MySqlParserREBUILD, MySqlParserRECOVER, MySqlParserRECURSIVE, MySqlParserREDO_BUFFER_SIZE, MySqlParserREDUNDANT, MySqlParserRELAY, MySqlParserRELAY_LOG_FILE, MySqlParserRELAY_LOG_POS, MySqlParserRELAYLOG, MySqlParserREMOVE, MySqlParserREORGANIZE, MySqlParserREPAIR, MySqlParserREPLICATE_DO_DB, MySqlParserREPLICATE_DO_TABLE, MySqlParserREPLICATE_IGNORE_DB, MySqlParserREPLICATE_IGNORE_TABLE, MySqlParserREPLICATE_REWRITE_DB, MySqlParserREPLICATE_WILD_DO_TABLE, MySqlParserREPLICATE_WILD_IGNORE_TABLE, MySqlParserREPLICATION, MySqlParserRESET, MySqlParserRESUME, MySqlParserRETURNED_SQLSTATE, MySqlParserRETURNING, MySqlParserRETURNS, MySqlParserREUSE, MySqlParserROLE, MySqlParserROLLBACK, MySqlParserROLLUP, MySqlParserROTATE, MySqlParserROW, MySqlParserROWS, MySqlParserROW_FORMAT, MySqlParserRTREE, MySqlParserSAVEPOINT, MySqlParserSCHEDULE, MySqlParserSECURITY, MySqlParserSERVER, MySqlParserSESSION, MySqlParserSHARE, MySqlParserSHARED, MySqlParserSIGNED, MySqlParserSIMPLE, MySqlParserSLAVE, MySqlParserSLOW, MySqlParserSNAPSHOT, MySqlParserSOCKET, MySqlParserSOME, MySqlParserSONAME, MySqlParserSOUNDS, MySqlParserSOURCE, MySqlParserSQL_AFTER_GTIDS, MySqlParserSQL_AFTER_MTS_GAPS, MySqlParserSQL_BEFORE_GTIDS, MySqlParserSQL_BUFFER_RESULT, MySqlParserSQL_CACHE, MySqlParserSQL_NO_CACHE, MySqlParserSQL_THREAD, MySqlParserSTART, MySqlParserSTARTS, MySqlParserSTATS_AUTO_RECALC, MySqlParserSTATS_PERSISTENT, MySqlParserSTATS_SAMPLE_PAGES, MySqlParserSTATUS, MySqlParserSTOP, MySqlParserSTORAGE, MySqlParserSTRING, MySqlParserSUBCLASS_ORIGIN, MySqlParserSUBJECT, MySqlParserSUBPARTITION, MySqlParserSUBPARTITIONS, MySqlParserSUSPEND, MySqlParserSWAPS, MySqlParserSWITCHES, MySqlParserTABLE_NAME, MySqlParserTABLESPACE, MySqlParserTABLE_TYPE, MySqlParserTEMPORARY, MySqlParserTEMPTABLE, MySqlParserTHAN, MySqlParserTRADITIONAL, MySqlParserTRANSACTION, MySqlParserTRANSACTIONAL, MySqlParserTRIGGERS, MySqlParserTRUNCATE, MySqlParserUNBOUNDED, MySqlParserUNDEFINED, MySqlParserUNDOFILE, MySqlParserUNDO_BUFFER_SIZE, MySqlParserUNINSTALL, MySqlParserUNKNOWN, MySqlParserUNTIL, MySqlParserUPGRADE, MySqlParserUSER, MySqlParserUSE_FRM, MySqlParserUSER_RESOURCES, MySqlParserVALIDATION, MySqlParserVALUE, MySqlParserVARIABLES, MySqlParserVIEW, MySqlParserVIRTUAL, MySqlParserVISIBLE, MySqlParserWAIT, MySqlParserWARNINGS, MySqlParserWITHOUT, MySqlParserWORK, MySqlParserWRAPPER, MySqlParserX509, MySqlParserXA, MySqlParserXML, MySqlParserYES, MySqlParserEUR, MySqlParserUSA, MySqlParserJIS, MySqlParserISO, MySqlParserINTERNAL, MySqlParserQUARTER, MySqlParserMONTH, MySqlParserDAY, MySqlParserHOUR, MySqlParserMINUTE, MySqlParserWEEK, MySqlParserSECOND, MySqlParserMICROSECOND, MySqlParserADMIN, MySqlParserAUDIT_ABORT_EXEMPT, MySqlParserAUDIT_ADMIN, MySqlParserAUTHENTICATION_POLICY_ADMIN, MySqlParserBACKUP_ADMIN, MySqlParserBINLOG_ADMIN, MySqlParserBINLOG_ENCRYPTION_ADMIN, MySqlParserCLONE_ADMIN, MySqlParserCONNECTION_ADMIN, MySqlParserENCRYPTION_KEY_ADMIN, MySqlParserEXECUTE, MySqlParserFILE, MySqlParserFIREWALL_ADMIN, MySqlParserFIREWALL_EXEMPT, MySqlParserFIREWALL_USER, MySqlParserGROUP_REPLICATION_ADMIN, MySqlParserINNODB_REDO_LOG_ARCHIVE, MySqlParserINVOKE, MySqlParserLAMBDA, MySqlParserNDB_STORED_USER, MySqlParserPASSWORDLESS_USER_ADMIN, MySqlParserPERSIST_RO_VARIABLES_ADMIN, MySqlParserPRIVILEGES, MySqlParserPROCESS, MySqlParserRELOAD, MySqlParserREPLICATION_APPLIER, MySqlParserREPLICATION_SLAVE_ADMIN, MySqlParserRESOURCE_GROUP_ADMIN, MySqlParserRESOURCE_GROUP_USER, MySqlParserROLE_ADMIN, MySqlParserROUTINE, MySqlParserS3, MySqlParserSESSION_VARIABLES_ADMIN, MySqlParserSET_USER_ID, MySqlParserSHOW_ROUTINE, MySqlParserSHUTDOWN, MySqlParserSUPER, MySqlParserSYSTEM_VARIABLES_ADMIN, MySqlParserTABLES, MySqlParserTABLE_ENCRYPTION_ADMIN, MySqlParserVERSION_TOKEN_ADMIN, MySqlParserXA_RECOVER_ADMIN, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserARCHIVE, MySqlParserBLACKHOLE, MySqlParserCSV, MySqlParserFEDERATED, MySqlParserINNODB, MySqlParserMEMORY, MySqlParserMRG_MYISAM, MySqlParserMYISAM, MySqlParserNDB, MySqlParserNDBCLUSTER, MySqlParserPERFORMANCE_SCHEMA, MySqlParserTOKUDB, MySqlParserREPEATABLE, MySqlParserCOMMITTED, MySqlParserUNCOMMITTED, MySqlParserSERIALIZABLE, MySqlParserGEOMETRYCOLLECTION, MySqlParserLINESTRING, MySqlParserMULTILINESTRING, MySqlParserMULTIPOINT, MySqlParserMULTIPOLYGON, MySqlParserPOINT, MySqlParserPOLYGON, MySqlParserABS, MySqlParserACOS, MySqlParserADDDATE, MySqlParserADDTIME, MySqlParserAES_DECRYPT, MySqlParserAES_ENCRYPT, MySqlParserAREA, MySqlParserASBINARY, MySqlParserASIN, MySqlParserASTEXT, MySqlParserASWKB, MySqlParserASWKT, MySqlParserASYMMETRIC_DECRYPT, MySqlParserASYMMETRIC_DERIVE, MySqlParserASYMMETRIC_ENCRYPT, MySqlParserASYMMETRIC_SIGN, MySqlParserASYMMETRIC_VERIFY, MySqlParserATAN, MySqlParserATAN2, MySqlParserBENCHMARK, MySqlParserBIN, MySqlParserBIT_COUNT, MySqlParserBIT_LENGTH, MySqlParserBUFFER, MySqlParserCATALOG_NAME, MySqlParserCEIL, MySqlParserCEILING, MySqlParserCENTROID, MySqlParserCHARACTER_LENGTH, MySqlParserCHARSET, MySqlParserCHAR_LENGTH, MySqlParserCOERCIBILITY, MySqlParserCOLLATION, MySqlParserCOMPRESS, MySqlParserCONCAT, MySqlParserCONCAT_WS, MySqlParserCONNECTION_ID, MySqlParserCONV, MySqlParserCONVERT_TZ, MySqlParserCOS, MySqlParserCOT, MySqlParserCRC32, MySqlParserCREATE_ASYMMETRIC_PRIV_KEY, MySqlParserCREATE_ASYMMETRIC_PUB_KEY, MySqlParserCREATE_DH_PARAMETERS, MySqlParserCREATE_DIGEST, MySqlParserCROSSES, MySqlParserDATEDIFF, MySqlParserDATE_FORMAT, MySqlParserDAYNAME, MySqlParserDAYOFMONTH, MySqlParserDAYOFWEEK, MySqlParserDAYOFYEAR, MySqlParserDECODE, MySqlParserDEGREES, MySqlParserDES_DECRYPT, MySqlParserDES_ENCRYPT, MySqlParserDIMENSION, MySqlParserDISJOINT, MySqlParserDISTANCE, MySqlParserELT, MySqlParserENCODE, MySqlParserENCRYPT, MySqlParserENDPOINT, MySqlParserENGINE_ATTRIBUTE, MySqlParserENVELOPE, MySqlParserEQUALS, MySqlParserEXP, MySqlParserEXPORT_SET, MySqlParserEXTERIORRING, MySqlParserEXTRACTVALUE, MySqlParserFIELD, MySqlParserFIND_IN_SET, MySqlParserFLOOR, MySqlParserFORMAT, MySqlParserFOUND_ROWS, MySqlParserFROM_BASE64, MySqlParserFROM_DAYS, MySqlParserFROM_UNIXTIME, MySqlParserGEOMCOLLFROMTEXT, MySqlParserGEOMCOLLFROMWKB, MySqlParserGEOMETRYCOLLECTIONFROMTEXT, MySqlParserGEOMETRYCOLLECTIONFROMWKB, MySqlParserGEOMETRYFROMTEXT, MySqlParserGEOMETRYFROMWKB, MySqlParserGEOMETRYN, MySqlParserGEOMETRYTYPE, MySqlParserGEOMFROMTEXT, MySqlParserGEOMFROMWKB, MySqlParserGET_FORMAT, MySqlParserGET_LOCK, MySqlParserGLENGTH, MySqlParserGREATEST, MySqlParserGTID_SUBSET, MySqlParserGTID_SUBTRACT, MySqlParserHEX, MySqlParserIFNULL, MySqlParserINET6_ATON, MySqlParserINET6_NTOA, MySqlParserINET_ATON, MySqlParserINET_NTOA, MySqlParserINSTR, MySqlParserINTERIORRINGN, MySqlParserINTERSECTS, MySqlParserISCLOSED, MySqlParserISEMPTY, MySqlParserISNULL, MySqlParserISSIMPLE, MySqlParserIS_FREE_LOCK, MySqlParserIS_IPV4, MySqlParserIS_IPV4_COMPAT, MySqlParserIS_IPV4_MAPPED, MySqlParserIS_IPV6, MySqlParserIS_USED_LOCK, MySqlParserLAST_INSERT_ID, MySqlParserLCASE, MySqlParserLEAST, MySqlParserLENGTH, MySqlParserLINEFROMTEXT, MySqlParserLINEFROMWKB, MySqlParserLINESTRINGFROMTEXT, MySqlParserLINESTRINGFROMWKB, MySqlParserLN, MySqlParserLOAD_FILE, MySqlParserLOCATE, MySqlParserLOG, MySqlParserLOG10, MySqlParserLOG2, MySqlParserLOWER, MySqlParserLPAD, MySqlParserLTRIM, MySqlParserMAKEDATE, MySqlParserMAKETIME, MySqlParserMAKE_SET, MySqlParserMASTER_POS_WAIT, MySqlParserMBRCONTAINS, MySqlParserMBRDISJOINT, MySqlParserMBREQUAL, MySqlParserMBRINTERSECTS, MySqlParserMBROVERLAPS, MySqlParserMBRTOUCHES, MySqlParserMBRWITHIN, MySqlParserMD5, MySqlParserMLINEFROMTEXT, MySqlParserMLINEFROMWKB, MySqlParserMONTHNAME, MySqlParserMPOINTFROMTEXT, MySqlParserMPOINTFROMWKB, MySqlParserMPOLYFROMTEXT, MySqlParserMPOLYFROMWKB, MySqlParserMULTILINESTRINGFROMTEXT, MySqlParserMULTILINESTRINGFROMWKB, MySqlParserMULTIPOINTFROMTEXT, MySqlParserMULTIPOINTFROMWKB, MySqlParserMULTIPOLYGONFROMTEXT, MySqlParserMULTIPOLYGONFROMWKB, MySqlParserNAME_CONST, MySqlParserNULLIF, MySqlParserNUMGEOMETRIES, MySqlParserNUMINTERIORRINGS, MySqlParserNUMPOINTS, MySqlParserOCT, MySqlParserOCTET_LENGTH, MySqlParserORD, MySqlParserOVERLAPS, MySqlParserPERIOD_ADD, MySqlParserPERIOD_DIFF, MySqlParserPI, MySqlParserPOINTFROMTEXT, MySqlParserPOINTFROMWKB, MySqlParserPOINTN, MySqlParserPOLYFROMTEXT, MySqlParserPOLYFROMWKB, MySqlParserPOLYGONFROMTEXT, MySqlParserPOLYGONFROMWKB, MySqlParserPOW, MySqlParserPOWER, MySqlParserQUOTE, MySqlParserRADIANS, MySqlParserRAND, MySqlParserRANDOM, MySqlParserRANDOM_BYTES, MySqlParserRELEASE_LOCK, MySqlParserREVERSE, MySqlParserROUND, MySqlParserROW_COUNT, MySqlParserRPAD, MySqlParserRTRIM, MySqlParserSEC_TO_TIME, MySqlParserSECONDARY_ENGINE_ATTRIBUTE, MySqlParserSESSION_USER, MySqlParserSHA, MySqlParserSHA1, MySqlParserSHA2, MySqlParserSCHEMA_NAME, MySqlParserSIGN, MySqlParserSIN, MySqlParserSLEEP, MySqlParserSOUNDEX, MySqlParserSQL_THREAD_WAIT_AFTER_GTIDS, MySqlParserSQRT, MySqlParserSRID, MySqlParserSTARTPOINT, MySqlParserSTRCMP, MySqlParserSTR_TO_DATE, MySqlParserST_AREA, MySqlParserST_ASBINARY, MySqlParserST_ASTEXT, MySqlParserST_ASWKB, MySqlParserST_ASWKT, MySqlParserST_BUFFER, MySqlParserST_CENTROID, MySqlParserST_CONTAINS, MySqlParserST_CROSSES, MySqlParserST_DIFFERENCE, MySqlParserST_DIMENSION, MySqlParserST_DISJOINT, MySqlParserST_DISTANCE, MySqlParserST_ENDPOINT, MySqlParserST_ENVELOPE, MySqlParserST_EQUALS, MySqlParserST_EXTERIORRING, MySqlParserST_GEOMCOLLFROMTEXT, MySqlParserST_GEOMCOLLFROMTXT, MySqlParserST_GEOMCOLLFROMWKB, MySqlParserST_GEOMETRYCOLLECTIONFROMTEXT, MySqlParserST_GEOMETRYCOLLECTIONFROMWKB, MySqlParserST_GEOMETRYFROMTEXT, MySqlParserST_GEOMETRYFROMWKB, MySqlParserST_GEOMETRYN, MySqlParserST_GEOMETRYTYPE, MySqlParserST_GEOMFROMTEXT, MySqlParserST_GEOMFROMWKB, MySqlParserST_INTERIORRINGN, MySqlParserST_INTERSECTION, MySqlParserST_INTERSECTS, MySqlParserST_ISCLOSED, MySqlParserST_ISEMPTY, MySqlParserST_ISSIMPLE, MySqlParserST_LINEFROMTEXT, MySqlParserST_LINEFROMWKB, MySqlParserST_LINESTRINGFROMTEXT, MySqlParserST_LINESTRINGFROMWKB, MySqlParserST_NUMGEOMETRIES, MySqlParserST_NUMINTERIORRING, MySqlParserST_NUMINTERIORRINGS, MySqlParserST_NUMPOINTS, MySqlParserST_OVERLAPS, MySqlParserST_POINTFROMTEXT, MySqlParserST_POINTFROMWKB, MySqlParserST_POINTN, MySqlParserST_POLYFROMTEXT, MySqlParserST_POLYFROMWKB, MySqlParserST_POLYGONFROMTEXT, MySqlParserST_POLYGONFROMWKB, MySqlParserST_SRID, MySqlParserST_STARTPOINT, MySqlParserST_SYMDIFFERENCE, MySqlParserST_TOUCHES, MySqlParserST_UNION, MySqlParserST_WITHIN, MySqlParserST_X, MySqlParserST_Y, MySqlParserSTRING_TO_VECTOR, MySqlParserSUBDATE, MySqlParserSUBSTRING_INDEX, MySqlParserSUBTIME, MySqlParserSYSTEM_USER, MySqlParserTAN, MySqlParserTIMEDIFF, MySqlParserTIMESTAMPADD, MySqlParserTIMESTAMPDIFF, MySqlParserTIME_FORMAT, MySqlParserTIME_TO_SEC, MySqlParserTOUCHES, MySqlParserTO_BASE64, MySqlParserTO_DAYS, MySqlParserTO_SECONDS, MySqlParserTP_CONNECTION_ADMIN, MySqlParserUCASE, MySqlParserUNCOMPRESS, MySqlParserUNCOMPRESSED_LENGTH, MySqlParserUNHEX, MySqlParserUNIX_TIMESTAMP, MySqlParserUPDATEXML, MySqlParserUPPER, MySqlParserUUID, MySqlParserUUID_SHORT, MySqlParserVALIDATE_PASSWORD_STRENGTH, MySqlParserVECTOR_DIM, MySqlParserVECTOR_TO_STRING, MySqlParserVERSION, MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS, MySqlParserWEEKDAY, MySqlParserWEEKOFYEAR, MySqlParserWEIGHT_STRING, MySqlParserWITHIN, MySqlParserYEARWEEK, MySqlParserY_FUNCTION, MySqlParserX_FUNCTION, MySqlParserMOD, MySqlParserCHARSET_REVERSE_QOUTE_STRING, MySqlParserSTRING_LITERAL, MySqlParserID: + { + p.SetState(2957) + p.UidList() + } + + case MySqlParserALL: + { + p.SetState(2958) + p.Match(MySqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case MySqlParserOPTIMIZE: + localctx = NewAlterByOptimizePartitionContext(p, localctx) + p.EnterOuterAlt(localctx, 11) + { + p.SetState(2961) + p.Match(MySqlParserOPTIMIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2962) + p.Match(MySqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2965) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserARRAY, MySqlParserATTRIBUTE, MySqlParserBUCKETS, MySqlParserCONDITION, MySqlParserCURRENT, MySqlParserCURRENT_USER, MySqlParserDATABASE, MySqlParserDEFAULT, MySqlParserDIAGNOSTICS, MySqlParserEMPTY, MySqlParserENFORCED, MySqlParserEXCEPT, MySqlParserGROUP, MySqlParserIF, MySqlParserIGNORED, MySqlParserINSERT, MySqlParserLATERAL, MySqlParserLEFT, MySqlParserNUMBER, MySqlParserOPTIONAL, MySqlParserORDER, MySqlParserPRIMARY, MySqlParserREPEAT, MySqlParserREPLACE, MySqlParserRIGHT, MySqlParserSCHEMA, MySqlParserSKIP_QUERY_REWRITE, MySqlParserSTACKED, MySqlParserSTATEMENT, MySqlParserDATE, MySqlParserTIME, MySqlParserTIMESTAMP, MySqlParserDATETIME, MySqlParserYEAR, MySqlParserBINARY, MySqlParserTEXT, MySqlParserENUM, MySqlParserSERIAL, MySqlParserJSON_ARRAY, MySqlParserJSON_ARRAYAGG, MySqlParserJSON_ARRAY_APPEND, MySqlParserJSON_ARRAY_INSERT, MySqlParserJSON_CONTAINS, MySqlParserJSON_CONTAINS_PATH, MySqlParserJSON_DEPTH, MySqlParserJSON_EXTRACT, MySqlParserJSON_INSERT, MySqlParserJSON_KEYS, MySqlParserJSON_LENGTH, MySqlParserJSON_MERGE, MySqlParserJSON_MERGE_PATCH, MySqlParserJSON_MERGE_PRESERVE, MySqlParserJSON_OBJECT, MySqlParserJSON_OBJECTAGG, MySqlParserJSON_OVERLAPS, MySqlParserJSON_PRETTY, MySqlParserJSON_QUOTE, MySqlParserJSON_REMOVE, MySqlParserJSON_REPLACE, MySqlParserJSON_SCHEMA_VALID, MySqlParserJSON_SCHEMA_VALIDATION_REPORT, MySqlParserJSON_SEARCH, MySqlParserJSON_SET, MySqlParserJSON_STORAGE_FREE, MySqlParserJSON_STORAGE_SIZE, MySqlParserJSON_TABLE, MySqlParserJSON_TYPE, MySqlParserJSON_UNQUOTE, MySqlParserJSON_VALID, MySqlParserJSON_VALUE, MySqlParserNESTED, MySqlParserORDINALITY, MySqlParserPATH, MySqlParserAVG, MySqlParserBIT_AND, MySqlParserBIT_OR, MySqlParserBIT_XOR, MySqlParserCOUNT, MySqlParserCUME_DIST, MySqlParserDENSE_RANK, MySqlParserFIRST_VALUE, MySqlParserGROUP_CONCAT, MySqlParserLAG, MySqlParserLAST_VALUE, MySqlParserLEAD, MySqlParserMAX, MySqlParserMIN, MySqlParserNTILE, MySqlParserNTH_VALUE, MySqlParserPERCENT_RANK, MySqlParserRANK, MySqlParserROW_NUMBER, MySqlParserSTD, MySqlParserSTDDEV, MySqlParserSTDDEV_POP, MySqlParserSTDDEV_SAMP, MySqlParserSUM, MySqlParserVAR_POP, MySqlParserVAR_SAMP, MySqlParserVARIANCE, MySqlParserCURRENT_DATE, MySqlParserCURRENT_TIME, MySqlParserCURRENT_TIMESTAMP, MySqlParserLOCALTIME, MySqlParserCURDATE, MySqlParserCURTIME, MySqlParserDATE_ADD, MySqlParserDATE_SUB, MySqlParserLOCALTIMESTAMP, MySqlParserNOW, MySqlParserPOSITION, MySqlParserSUBSTR, MySqlParserSUBSTRING, MySqlParserSYSDATE, MySqlParserTRIM, MySqlParserUTC_DATE, MySqlParserUTC_TIME, MySqlParserUTC_TIMESTAMP, MySqlParserACCOUNT, MySqlParserACTION, MySqlParserAFTER, MySqlParserAGGREGATE, MySqlParserALGORITHM, MySqlParserANY, MySqlParserAT, MySqlParserAUTHORS, MySqlParserAUTOCOMMIT, MySqlParserAUTOEXTEND_SIZE, MySqlParserAUTO_INCREMENT, MySqlParserAVG_ROW_LENGTH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserBIT, MySqlParserBLOCK, MySqlParserBOOL, MySqlParserBOOLEAN, MySqlParserBTREE, MySqlParserCACHE, MySqlParserCASCADED, MySqlParserCHAIN, MySqlParserCHANGED, MySqlParserCHANNEL, MySqlParserCHECKSUM, MySqlParserPAGE_CHECKSUM, MySqlParserCIPHER, MySqlParserCLASS_ORIGIN, MySqlParserCLIENT, MySqlParserCLOSE, MySqlParserCLUSTERING, MySqlParserCOALESCE, MySqlParserCODE, MySqlParserCOLUMNS, MySqlParserCOLUMN_FORMAT, MySqlParserCOLUMN_NAME, MySqlParserCOMMENT, MySqlParserCOMMIT, MySqlParserCOMPACT, MySqlParserCOMPLETION, MySqlParserCOMPRESSED, MySqlParserCOMPRESSION, MySqlParserCONCURRENT, MySqlParserCONNECT, MySqlParserCONNECTION, MySqlParserCONSISTENT, MySqlParserCONSTRAINT_CATALOG, MySqlParserCONSTRAINT_SCHEMA, MySqlParserCONSTRAINT_NAME, MySqlParserCONTAINS, MySqlParserCONTEXT, MySqlParserCONTRIBUTORS, MySqlParserCOPY, MySqlParserCPU, MySqlParserCURSOR_NAME, MySqlParserDATA, MySqlParserDATAFILE, MySqlParserDEALLOCATE, MySqlParserDEFAULT_AUTH, MySqlParserDEFINER, MySqlParserDELAY_KEY_WRITE, MySqlParserDES_KEY_FILE, MySqlParserDIRECTORY, MySqlParserDISABLE, MySqlParserDISCARD, MySqlParserDISK, MySqlParserDO, MySqlParserDUMPFILE, MySqlParserDUPLICATE, MySqlParserDYNAMIC, MySqlParserENABLE, MySqlParserENCRYPTION, MySqlParserEND, MySqlParserENDS, MySqlParserENGINE, MySqlParserENGINES, MySqlParserERROR, MySqlParserERRORS, MySqlParserESCAPE, MySqlParserEVEN, MySqlParserEVENT, MySqlParserEVENTS, MySqlParserEVERY, MySqlParserEXCHANGE, MySqlParserEXCLUSIVE, MySqlParserEXPIRE, MySqlParserEXPORT, MySqlParserEXTENDED, MySqlParserEXTENT_SIZE, MySqlParserFAILED_LOGIN_ATTEMPTS, MySqlParserFAST, MySqlParserFAULTS, MySqlParserFIELDS, MySqlParserFILE_BLOCK_SIZE, MySqlParserFILTER, MySqlParserFIRST, MySqlParserFIXED, MySqlParserFLUSH, MySqlParserFOLLOWS, MySqlParserFOUND, MySqlParserFULL, MySqlParserFUNCTION, MySqlParserGENERAL, MySqlParserGLOBAL, MySqlParserGRANTS, MySqlParserGROUP_REPLICATION, MySqlParserHANDLER, MySqlParserHASH, MySqlParserHELP, MySqlParserHISTORY, MySqlParserHOST, MySqlParserHOSTS, MySqlParserIDENTIFIED, MySqlParserIGNORE_SERVER_IDS, MySqlParserIMPORT, MySqlParserINDEXES, MySqlParserINITIAL_SIZE, MySqlParserINPLACE, MySqlParserINSERT_METHOD, MySqlParserINSTALL, MySqlParserINSTANCE, MySqlParserINSTANT, MySqlParserINVISIBLE, MySqlParserINVOKER, MySqlParserIO, MySqlParserIO_THREAD, MySqlParserIPC, MySqlParserISOLATION, MySqlParserISSUER, MySqlParserJSON, MySqlParserKEY_BLOCK_SIZE, MySqlParserLANGUAGE, MySqlParserLAST, MySqlParserLEAVES, MySqlParserLESS, MySqlParserLEVEL, MySqlParserLIST, MySqlParserLOCAL, MySqlParserLOGFILE, MySqlParserLOGS, MySqlParserMASTER, MySqlParserMASTER_AUTO_POSITION, MySqlParserMASTER_CONNECT_RETRY, MySqlParserMASTER_DELAY, MySqlParserMASTER_HEARTBEAT_PERIOD, MySqlParserMASTER_HOST, MySqlParserMASTER_LOG_FILE, MySqlParserMASTER_LOG_POS, MySqlParserMASTER_PASSWORD, MySqlParserMASTER_PORT, MySqlParserMASTER_RETRY_COUNT, MySqlParserMASTER_SSL, MySqlParserMASTER_SSL_CA, MySqlParserMASTER_SSL_CAPATH, MySqlParserMASTER_SSL_CERT, MySqlParserMASTER_SSL_CIPHER, MySqlParserMASTER_SSL_CRL, MySqlParserMASTER_SSL_CRLPATH, MySqlParserMASTER_SSL_KEY, MySqlParserMASTER_TLS_VERSION, MySqlParserMASTER_USER, MySqlParserMAX_CONNECTIONS_PER_HOUR, MySqlParserMAX_QUERIES_PER_HOUR, MySqlParserMAX_ROWS, MySqlParserMAX_SIZE, MySqlParserMAX_UPDATES_PER_HOUR, MySqlParserMAX_USER_CONNECTIONS, MySqlParserMEDIUM, MySqlParserMEMBER, MySqlParserMERGE, MySqlParserMESSAGE_TEXT, MySqlParserMID, MySqlParserMIGRATE, MySqlParserMIN_ROWS, MySqlParserMODE, MySqlParserMODIFY, MySqlParserMUTEX, MySqlParserMYSQL, MySqlParserMYSQL_ERRNO, MySqlParserNAME, MySqlParserNAMES, MySqlParserNCHAR, MySqlParserNEVER, MySqlParserNEXT, MySqlParserNO, MySqlParserNOCOPY, MySqlParserNOWAIT, MySqlParserNODEGROUP, MySqlParserNONE, MySqlParserODBC, MySqlParserOFFLINE, MySqlParserOFFSET, MySqlParserOF, MySqlParserOJ, MySqlParserOLD_PASSWORD, MySqlParserONE, MySqlParserONLINE, MySqlParserONLY, MySqlParserOPEN, MySqlParserOPTIMIZER_COSTS, MySqlParserOPTIONS, MySqlParserOWNER, MySqlParserPACK_KEYS, MySqlParserPAGE, MySqlParserPARSER, MySqlParserPARTIAL, MySqlParserPARTITIONING, MySqlParserPARTITIONS, MySqlParserPASSWORD, MySqlParserPASSWORD_LOCK_TIME, MySqlParserPHASE, MySqlParserPLUGIN, MySqlParserPLUGIN_DIR, MySqlParserPLUGINS, MySqlParserPORT, MySqlParserPRECEDES, MySqlParserPREPARE, MySqlParserPRESERVE, MySqlParserPREV, MySqlParserPROCESSLIST, MySqlParserPROFILE, MySqlParserPROFILES, MySqlParserPROXY, MySqlParserQUERY, MySqlParserQUICK, MySqlParserREBUILD, MySqlParserRECOVER, MySqlParserRECURSIVE, MySqlParserREDO_BUFFER_SIZE, MySqlParserREDUNDANT, MySqlParserRELAY, MySqlParserRELAY_LOG_FILE, MySqlParserRELAY_LOG_POS, MySqlParserRELAYLOG, MySqlParserREMOVE, MySqlParserREORGANIZE, MySqlParserREPAIR, MySqlParserREPLICATE_DO_DB, MySqlParserREPLICATE_DO_TABLE, MySqlParserREPLICATE_IGNORE_DB, MySqlParserREPLICATE_IGNORE_TABLE, MySqlParserREPLICATE_REWRITE_DB, MySqlParserREPLICATE_WILD_DO_TABLE, MySqlParserREPLICATE_WILD_IGNORE_TABLE, MySqlParserREPLICATION, MySqlParserRESET, MySqlParserRESUME, MySqlParserRETURNED_SQLSTATE, MySqlParserRETURNING, MySqlParserRETURNS, MySqlParserREUSE, MySqlParserROLE, MySqlParserROLLBACK, MySqlParserROLLUP, MySqlParserROTATE, MySqlParserROW, MySqlParserROWS, MySqlParserROW_FORMAT, MySqlParserRTREE, MySqlParserSAVEPOINT, MySqlParserSCHEDULE, MySqlParserSECURITY, MySqlParserSERVER, MySqlParserSESSION, MySqlParserSHARE, MySqlParserSHARED, MySqlParserSIGNED, MySqlParserSIMPLE, MySqlParserSLAVE, MySqlParserSLOW, MySqlParserSNAPSHOT, MySqlParserSOCKET, MySqlParserSOME, MySqlParserSONAME, MySqlParserSOUNDS, MySqlParserSOURCE, MySqlParserSQL_AFTER_GTIDS, MySqlParserSQL_AFTER_MTS_GAPS, MySqlParserSQL_BEFORE_GTIDS, MySqlParserSQL_BUFFER_RESULT, MySqlParserSQL_CACHE, MySqlParserSQL_NO_CACHE, MySqlParserSQL_THREAD, MySqlParserSTART, MySqlParserSTARTS, MySqlParserSTATS_AUTO_RECALC, MySqlParserSTATS_PERSISTENT, MySqlParserSTATS_SAMPLE_PAGES, MySqlParserSTATUS, MySqlParserSTOP, MySqlParserSTORAGE, MySqlParserSTRING, MySqlParserSUBCLASS_ORIGIN, MySqlParserSUBJECT, MySqlParserSUBPARTITION, MySqlParserSUBPARTITIONS, MySqlParserSUSPEND, MySqlParserSWAPS, MySqlParserSWITCHES, MySqlParserTABLE_NAME, MySqlParserTABLESPACE, MySqlParserTABLE_TYPE, MySqlParserTEMPORARY, MySqlParserTEMPTABLE, MySqlParserTHAN, MySqlParserTRADITIONAL, MySqlParserTRANSACTION, MySqlParserTRANSACTIONAL, MySqlParserTRIGGERS, MySqlParserTRUNCATE, MySqlParserUNBOUNDED, MySqlParserUNDEFINED, MySqlParserUNDOFILE, MySqlParserUNDO_BUFFER_SIZE, MySqlParserUNINSTALL, MySqlParserUNKNOWN, MySqlParserUNTIL, MySqlParserUPGRADE, MySqlParserUSER, MySqlParserUSE_FRM, MySqlParserUSER_RESOURCES, MySqlParserVALIDATION, MySqlParserVALUE, MySqlParserVARIABLES, MySqlParserVIEW, MySqlParserVIRTUAL, MySqlParserVISIBLE, MySqlParserWAIT, MySqlParserWARNINGS, MySqlParserWITHOUT, MySqlParserWORK, MySqlParserWRAPPER, MySqlParserX509, MySqlParserXA, MySqlParserXML, MySqlParserYES, MySqlParserEUR, MySqlParserUSA, MySqlParserJIS, MySqlParserISO, MySqlParserINTERNAL, MySqlParserQUARTER, MySqlParserMONTH, MySqlParserDAY, MySqlParserHOUR, MySqlParserMINUTE, MySqlParserWEEK, MySqlParserSECOND, MySqlParserMICROSECOND, MySqlParserADMIN, MySqlParserAUDIT_ABORT_EXEMPT, MySqlParserAUDIT_ADMIN, MySqlParserAUTHENTICATION_POLICY_ADMIN, MySqlParserBACKUP_ADMIN, MySqlParserBINLOG_ADMIN, MySqlParserBINLOG_ENCRYPTION_ADMIN, MySqlParserCLONE_ADMIN, MySqlParserCONNECTION_ADMIN, MySqlParserENCRYPTION_KEY_ADMIN, MySqlParserEXECUTE, MySqlParserFILE, MySqlParserFIREWALL_ADMIN, MySqlParserFIREWALL_EXEMPT, MySqlParserFIREWALL_USER, MySqlParserGROUP_REPLICATION_ADMIN, MySqlParserINNODB_REDO_LOG_ARCHIVE, MySqlParserINVOKE, MySqlParserLAMBDA, MySqlParserNDB_STORED_USER, MySqlParserPASSWORDLESS_USER_ADMIN, MySqlParserPERSIST_RO_VARIABLES_ADMIN, MySqlParserPRIVILEGES, MySqlParserPROCESS, MySqlParserRELOAD, MySqlParserREPLICATION_APPLIER, MySqlParserREPLICATION_SLAVE_ADMIN, MySqlParserRESOURCE_GROUP_ADMIN, MySqlParserRESOURCE_GROUP_USER, MySqlParserROLE_ADMIN, MySqlParserROUTINE, MySqlParserS3, MySqlParserSESSION_VARIABLES_ADMIN, MySqlParserSET_USER_ID, MySqlParserSHOW_ROUTINE, MySqlParserSHUTDOWN, MySqlParserSUPER, MySqlParserSYSTEM_VARIABLES_ADMIN, MySqlParserTABLES, MySqlParserTABLE_ENCRYPTION_ADMIN, MySqlParserVERSION_TOKEN_ADMIN, MySqlParserXA_RECOVER_ADMIN, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserARCHIVE, MySqlParserBLACKHOLE, MySqlParserCSV, MySqlParserFEDERATED, MySqlParserINNODB, MySqlParserMEMORY, MySqlParserMRG_MYISAM, MySqlParserMYISAM, MySqlParserNDB, MySqlParserNDBCLUSTER, MySqlParserPERFORMANCE_SCHEMA, MySqlParserTOKUDB, MySqlParserREPEATABLE, MySqlParserCOMMITTED, MySqlParserUNCOMMITTED, MySqlParserSERIALIZABLE, MySqlParserGEOMETRYCOLLECTION, MySqlParserLINESTRING, MySqlParserMULTILINESTRING, MySqlParserMULTIPOINT, MySqlParserMULTIPOLYGON, MySqlParserPOINT, MySqlParserPOLYGON, MySqlParserABS, MySqlParserACOS, MySqlParserADDDATE, MySqlParserADDTIME, MySqlParserAES_DECRYPT, MySqlParserAES_ENCRYPT, MySqlParserAREA, MySqlParserASBINARY, MySqlParserASIN, MySqlParserASTEXT, MySqlParserASWKB, MySqlParserASWKT, MySqlParserASYMMETRIC_DECRYPT, MySqlParserASYMMETRIC_DERIVE, MySqlParserASYMMETRIC_ENCRYPT, MySqlParserASYMMETRIC_SIGN, MySqlParserASYMMETRIC_VERIFY, MySqlParserATAN, MySqlParserATAN2, MySqlParserBENCHMARK, MySqlParserBIN, MySqlParserBIT_COUNT, MySqlParserBIT_LENGTH, MySqlParserBUFFER, MySqlParserCATALOG_NAME, MySqlParserCEIL, MySqlParserCEILING, MySqlParserCENTROID, MySqlParserCHARACTER_LENGTH, MySqlParserCHARSET, MySqlParserCHAR_LENGTH, MySqlParserCOERCIBILITY, MySqlParserCOLLATION, MySqlParserCOMPRESS, MySqlParserCONCAT, MySqlParserCONCAT_WS, MySqlParserCONNECTION_ID, MySqlParserCONV, MySqlParserCONVERT_TZ, MySqlParserCOS, MySqlParserCOT, MySqlParserCRC32, MySqlParserCREATE_ASYMMETRIC_PRIV_KEY, MySqlParserCREATE_ASYMMETRIC_PUB_KEY, MySqlParserCREATE_DH_PARAMETERS, MySqlParserCREATE_DIGEST, MySqlParserCROSSES, MySqlParserDATEDIFF, MySqlParserDATE_FORMAT, MySqlParserDAYNAME, MySqlParserDAYOFMONTH, MySqlParserDAYOFWEEK, MySqlParserDAYOFYEAR, MySqlParserDECODE, MySqlParserDEGREES, MySqlParserDES_DECRYPT, MySqlParserDES_ENCRYPT, MySqlParserDIMENSION, MySqlParserDISJOINT, MySqlParserDISTANCE, MySqlParserELT, MySqlParserENCODE, MySqlParserENCRYPT, MySqlParserENDPOINT, MySqlParserENGINE_ATTRIBUTE, MySqlParserENVELOPE, MySqlParserEQUALS, MySqlParserEXP, MySqlParserEXPORT_SET, MySqlParserEXTERIORRING, MySqlParserEXTRACTVALUE, MySqlParserFIELD, MySqlParserFIND_IN_SET, MySqlParserFLOOR, MySqlParserFORMAT, MySqlParserFOUND_ROWS, MySqlParserFROM_BASE64, MySqlParserFROM_DAYS, MySqlParserFROM_UNIXTIME, MySqlParserGEOMCOLLFROMTEXT, MySqlParserGEOMCOLLFROMWKB, MySqlParserGEOMETRYCOLLECTIONFROMTEXT, MySqlParserGEOMETRYCOLLECTIONFROMWKB, MySqlParserGEOMETRYFROMTEXT, MySqlParserGEOMETRYFROMWKB, MySqlParserGEOMETRYN, MySqlParserGEOMETRYTYPE, MySqlParserGEOMFROMTEXT, MySqlParserGEOMFROMWKB, MySqlParserGET_FORMAT, MySqlParserGET_LOCK, MySqlParserGLENGTH, MySqlParserGREATEST, MySqlParserGTID_SUBSET, MySqlParserGTID_SUBTRACT, MySqlParserHEX, MySqlParserIFNULL, MySqlParserINET6_ATON, MySqlParserINET6_NTOA, MySqlParserINET_ATON, MySqlParserINET_NTOA, MySqlParserINSTR, MySqlParserINTERIORRINGN, MySqlParserINTERSECTS, MySqlParserISCLOSED, MySqlParserISEMPTY, MySqlParserISNULL, MySqlParserISSIMPLE, MySqlParserIS_FREE_LOCK, MySqlParserIS_IPV4, MySqlParserIS_IPV4_COMPAT, MySqlParserIS_IPV4_MAPPED, MySqlParserIS_IPV6, MySqlParserIS_USED_LOCK, MySqlParserLAST_INSERT_ID, MySqlParserLCASE, MySqlParserLEAST, MySqlParserLENGTH, MySqlParserLINEFROMTEXT, MySqlParserLINEFROMWKB, MySqlParserLINESTRINGFROMTEXT, MySqlParserLINESTRINGFROMWKB, MySqlParserLN, MySqlParserLOAD_FILE, MySqlParserLOCATE, MySqlParserLOG, MySqlParserLOG10, MySqlParserLOG2, MySqlParserLOWER, MySqlParserLPAD, MySqlParserLTRIM, MySqlParserMAKEDATE, MySqlParserMAKETIME, MySqlParserMAKE_SET, MySqlParserMASTER_POS_WAIT, MySqlParserMBRCONTAINS, MySqlParserMBRDISJOINT, MySqlParserMBREQUAL, MySqlParserMBRINTERSECTS, MySqlParserMBROVERLAPS, MySqlParserMBRTOUCHES, MySqlParserMBRWITHIN, MySqlParserMD5, MySqlParserMLINEFROMTEXT, MySqlParserMLINEFROMWKB, MySqlParserMONTHNAME, MySqlParserMPOINTFROMTEXT, MySqlParserMPOINTFROMWKB, MySqlParserMPOLYFROMTEXT, MySqlParserMPOLYFROMWKB, MySqlParserMULTILINESTRINGFROMTEXT, MySqlParserMULTILINESTRINGFROMWKB, MySqlParserMULTIPOINTFROMTEXT, MySqlParserMULTIPOINTFROMWKB, MySqlParserMULTIPOLYGONFROMTEXT, MySqlParserMULTIPOLYGONFROMWKB, MySqlParserNAME_CONST, MySqlParserNULLIF, MySqlParserNUMGEOMETRIES, MySqlParserNUMINTERIORRINGS, MySqlParserNUMPOINTS, MySqlParserOCT, MySqlParserOCTET_LENGTH, MySqlParserORD, MySqlParserOVERLAPS, MySqlParserPERIOD_ADD, MySqlParserPERIOD_DIFF, MySqlParserPI, MySqlParserPOINTFROMTEXT, MySqlParserPOINTFROMWKB, MySqlParserPOINTN, MySqlParserPOLYFROMTEXT, MySqlParserPOLYFROMWKB, MySqlParserPOLYGONFROMTEXT, MySqlParserPOLYGONFROMWKB, MySqlParserPOW, MySqlParserPOWER, MySqlParserQUOTE, MySqlParserRADIANS, MySqlParserRAND, MySqlParserRANDOM, MySqlParserRANDOM_BYTES, MySqlParserRELEASE_LOCK, MySqlParserREVERSE, MySqlParserROUND, MySqlParserROW_COUNT, MySqlParserRPAD, MySqlParserRTRIM, MySqlParserSEC_TO_TIME, MySqlParserSECONDARY_ENGINE_ATTRIBUTE, MySqlParserSESSION_USER, MySqlParserSHA, MySqlParserSHA1, MySqlParserSHA2, MySqlParserSCHEMA_NAME, MySqlParserSIGN, MySqlParserSIN, MySqlParserSLEEP, MySqlParserSOUNDEX, MySqlParserSQL_THREAD_WAIT_AFTER_GTIDS, MySqlParserSQRT, MySqlParserSRID, MySqlParserSTARTPOINT, MySqlParserSTRCMP, MySqlParserSTR_TO_DATE, MySqlParserST_AREA, MySqlParserST_ASBINARY, MySqlParserST_ASTEXT, MySqlParserST_ASWKB, MySqlParserST_ASWKT, MySqlParserST_BUFFER, MySqlParserST_CENTROID, MySqlParserST_CONTAINS, MySqlParserST_CROSSES, MySqlParserST_DIFFERENCE, MySqlParserST_DIMENSION, MySqlParserST_DISJOINT, MySqlParserST_DISTANCE, MySqlParserST_ENDPOINT, MySqlParserST_ENVELOPE, MySqlParserST_EQUALS, MySqlParserST_EXTERIORRING, MySqlParserST_GEOMCOLLFROMTEXT, MySqlParserST_GEOMCOLLFROMTXT, MySqlParserST_GEOMCOLLFROMWKB, MySqlParserST_GEOMETRYCOLLECTIONFROMTEXT, MySqlParserST_GEOMETRYCOLLECTIONFROMWKB, MySqlParserST_GEOMETRYFROMTEXT, MySqlParserST_GEOMETRYFROMWKB, MySqlParserST_GEOMETRYN, MySqlParserST_GEOMETRYTYPE, MySqlParserST_GEOMFROMTEXT, MySqlParserST_GEOMFROMWKB, MySqlParserST_INTERIORRINGN, MySqlParserST_INTERSECTION, MySqlParserST_INTERSECTS, MySqlParserST_ISCLOSED, MySqlParserST_ISEMPTY, MySqlParserST_ISSIMPLE, MySqlParserST_LINEFROMTEXT, MySqlParserST_LINEFROMWKB, MySqlParserST_LINESTRINGFROMTEXT, MySqlParserST_LINESTRINGFROMWKB, MySqlParserST_NUMGEOMETRIES, MySqlParserST_NUMINTERIORRING, MySqlParserST_NUMINTERIORRINGS, MySqlParserST_NUMPOINTS, MySqlParserST_OVERLAPS, MySqlParserST_POINTFROMTEXT, MySqlParserST_POINTFROMWKB, MySqlParserST_POINTN, MySqlParserST_POLYFROMTEXT, MySqlParserST_POLYFROMWKB, MySqlParserST_POLYGONFROMTEXT, MySqlParserST_POLYGONFROMWKB, MySqlParserST_SRID, MySqlParserST_STARTPOINT, MySqlParserST_SYMDIFFERENCE, MySqlParserST_TOUCHES, MySqlParserST_UNION, MySqlParserST_WITHIN, MySqlParserST_X, MySqlParserST_Y, MySqlParserSTRING_TO_VECTOR, MySqlParserSUBDATE, MySqlParserSUBSTRING_INDEX, MySqlParserSUBTIME, MySqlParserSYSTEM_USER, MySqlParserTAN, MySqlParserTIMEDIFF, MySqlParserTIMESTAMPADD, MySqlParserTIMESTAMPDIFF, MySqlParserTIME_FORMAT, MySqlParserTIME_TO_SEC, MySqlParserTOUCHES, MySqlParserTO_BASE64, MySqlParserTO_DAYS, MySqlParserTO_SECONDS, MySqlParserTP_CONNECTION_ADMIN, MySqlParserUCASE, MySqlParserUNCOMPRESS, MySqlParserUNCOMPRESSED_LENGTH, MySqlParserUNHEX, MySqlParserUNIX_TIMESTAMP, MySqlParserUPDATEXML, MySqlParserUPPER, MySqlParserUUID, MySqlParserUUID_SHORT, MySqlParserVALIDATE_PASSWORD_STRENGTH, MySqlParserVECTOR_DIM, MySqlParserVECTOR_TO_STRING, MySqlParserVERSION, MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS, MySqlParserWEEKDAY, MySqlParserWEEKOFYEAR, MySqlParserWEIGHT_STRING, MySqlParserWITHIN, MySqlParserYEARWEEK, MySqlParserY_FUNCTION, MySqlParserX_FUNCTION, MySqlParserMOD, MySqlParserCHARSET_REVERSE_QOUTE_STRING, MySqlParserSTRING_LITERAL, MySqlParserID: + { + p.SetState(2963) + p.UidList() + } + + case MySqlParserALL: + { + p.SetState(2964) + p.Match(MySqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case MySqlParserREBUILD: + localctx = NewAlterByRebuildPartitionContext(p, localctx) + p.EnterOuterAlt(localctx, 12) + { + p.SetState(2967) + p.Match(MySqlParserREBUILD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2968) + p.Match(MySqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2971) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserARRAY, MySqlParserATTRIBUTE, MySqlParserBUCKETS, MySqlParserCONDITION, MySqlParserCURRENT, MySqlParserCURRENT_USER, MySqlParserDATABASE, MySqlParserDEFAULT, MySqlParserDIAGNOSTICS, MySqlParserEMPTY, MySqlParserENFORCED, MySqlParserEXCEPT, MySqlParserGROUP, MySqlParserIF, MySqlParserIGNORED, MySqlParserINSERT, MySqlParserLATERAL, MySqlParserLEFT, MySqlParserNUMBER, MySqlParserOPTIONAL, MySqlParserORDER, MySqlParserPRIMARY, MySqlParserREPEAT, MySqlParserREPLACE, MySqlParserRIGHT, MySqlParserSCHEMA, MySqlParserSKIP_QUERY_REWRITE, MySqlParserSTACKED, MySqlParserSTATEMENT, MySqlParserDATE, MySqlParserTIME, MySqlParserTIMESTAMP, MySqlParserDATETIME, MySqlParserYEAR, MySqlParserBINARY, MySqlParserTEXT, MySqlParserENUM, MySqlParserSERIAL, MySqlParserJSON_ARRAY, MySqlParserJSON_ARRAYAGG, MySqlParserJSON_ARRAY_APPEND, MySqlParserJSON_ARRAY_INSERT, MySqlParserJSON_CONTAINS, MySqlParserJSON_CONTAINS_PATH, MySqlParserJSON_DEPTH, MySqlParserJSON_EXTRACT, MySqlParserJSON_INSERT, MySqlParserJSON_KEYS, MySqlParserJSON_LENGTH, MySqlParserJSON_MERGE, MySqlParserJSON_MERGE_PATCH, MySqlParserJSON_MERGE_PRESERVE, MySqlParserJSON_OBJECT, MySqlParserJSON_OBJECTAGG, MySqlParserJSON_OVERLAPS, MySqlParserJSON_PRETTY, MySqlParserJSON_QUOTE, MySqlParserJSON_REMOVE, MySqlParserJSON_REPLACE, MySqlParserJSON_SCHEMA_VALID, MySqlParserJSON_SCHEMA_VALIDATION_REPORT, MySqlParserJSON_SEARCH, MySqlParserJSON_SET, MySqlParserJSON_STORAGE_FREE, MySqlParserJSON_STORAGE_SIZE, MySqlParserJSON_TABLE, MySqlParserJSON_TYPE, MySqlParserJSON_UNQUOTE, MySqlParserJSON_VALID, MySqlParserJSON_VALUE, MySqlParserNESTED, MySqlParserORDINALITY, MySqlParserPATH, MySqlParserAVG, MySqlParserBIT_AND, MySqlParserBIT_OR, MySqlParserBIT_XOR, MySqlParserCOUNT, MySqlParserCUME_DIST, MySqlParserDENSE_RANK, MySqlParserFIRST_VALUE, MySqlParserGROUP_CONCAT, MySqlParserLAG, MySqlParserLAST_VALUE, MySqlParserLEAD, MySqlParserMAX, MySqlParserMIN, MySqlParserNTILE, MySqlParserNTH_VALUE, MySqlParserPERCENT_RANK, MySqlParserRANK, MySqlParserROW_NUMBER, MySqlParserSTD, MySqlParserSTDDEV, MySqlParserSTDDEV_POP, MySqlParserSTDDEV_SAMP, MySqlParserSUM, MySqlParserVAR_POP, MySqlParserVAR_SAMP, MySqlParserVARIANCE, MySqlParserCURRENT_DATE, MySqlParserCURRENT_TIME, MySqlParserCURRENT_TIMESTAMP, MySqlParserLOCALTIME, MySqlParserCURDATE, MySqlParserCURTIME, MySqlParserDATE_ADD, MySqlParserDATE_SUB, MySqlParserLOCALTIMESTAMP, MySqlParserNOW, MySqlParserPOSITION, MySqlParserSUBSTR, MySqlParserSUBSTRING, MySqlParserSYSDATE, MySqlParserTRIM, MySqlParserUTC_DATE, MySqlParserUTC_TIME, MySqlParserUTC_TIMESTAMP, MySqlParserACCOUNT, MySqlParserACTION, MySqlParserAFTER, MySqlParserAGGREGATE, MySqlParserALGORITHM, MySqlParserANY, MySqlParserAT, MySqlParserAUTHORS, MySqlParserAUTOCOMMIT, MySqlParserAUTOEXTEND_SIZE, MySqlParserAUTO_INCREMENT, MySqlParserAVG_ROW_LENGTH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserBIT, MySqlParserBLOCK, MySqlParserBOOL, MySqlParserBOOLEAN, MySqlParserBTREE, MySqlParserCACHE, MySqlParserCASCADED, MySqlParserCHAIN, MySqlParserCHANGED, MySqlParserCHANNEL, MySqlParserCHECKSUM, MySqlParserPAGE_CHECKSUM, MySqlParserCIPHER, MySqlParserCLASS_ORIGIN, MySqlParserCLIENT, MySqlParserCLOSE, MySqlParserCLUSTERING, MySqlParserCOALESCE, MySqlParserCODE, MySqlParserCOLUMNS, MySqlParserCOLUMN_FORMAT, MySqlParserCOLUMN_NAME, MySqlParserCOMMENT, MySqlParserCOMMIT, MySqlParserCOMPACT, MySqlParserCOMPLETION, MySqlParserCOMPRESSED, MySqlParserCOMPRESSION, MySqlParserCONCURRENT, MySqlParserCONNECT, MySqlParserCONNECTION, MySqlParserCONSISTENT, MySqlParserCONSTRAINT_CATALOG, MySqlParserCONSTRAINT_SCHEMA, MySqlParserCONSTRAINT_NAME, MySqlParserCONTAINS, MySqlParserCONTEXT, MySqlParserCONTRIBUTORS, MySqlParserCOPY, MySqlParserCPU, MySqlParserCURSOR_NAME, MySqlParserDATA, MySqlParserDATAFILE, MySqlParserDEALLOCATE, MySqlParserDEFAULT_AUTH, MySqlParserDEFINER, MySqlParserDELAY_KEY_WRITE, MySqlParserDES_KEY_FILE, MySqlParserDIRECTORY, MySqlParserDISABLE, MySqlParserDISCARD, MySqlParserDISK, MySqlParserDO, MySqlParserDUMPFILE, MySqlParserDUPLICATE, MySqlParserDYNAMIC, MySqlParserENABLE, MySqlParserENCRYPTION, MySqlParserEND, MySqlParserENDS, MySqlParserENGINE, MySqlParserENGINES, MySqlParserERROR, MySqlParserERRORS, MySqlParserESCAPE, MySqlParserEVEN, MySqlParserEVENT, MySqlParserEVENTS, MySqlParserEVERY, MySqlParserEXCHANGE, MySqlParserEXCLUSIVE, MySqlParserEXPIRE, MySqlParserEXPORT, MySqlParserEXTENDED, MySqlParserEXTENT_SIZE, MySqlParserFAILED_LOGIN_ATTEMPTS, MySqlParserFAST, MySqlParserFAULTS, MySqlParserFIELDS, MySqlParserFILE_BLOCK_SIZE, MySqlParserFILTER, MySqlParserFIRST, MySqlParserFIXED, MySqlParserFLUSH, MySqlParserFOLLOWS, MySqlParserFOUND, MySqlParserFULL, MySqlParserFUNCTION, MySqlParserGENERAL, MySqlParserGLOBAL, MySqlParserGRANTS, MySqlParserGROUP_REPLICATION, MySqlParserHANDLER, MySqlParserHASH, MySqlParserHELP, MySqlParserHISTORY, MySqlParserHOST, MySqlParserHOSTS, MySqlParserIDENTIFIED, MySqlParserIGNORE_SERVER_IDS, MySqlParserIMPORT, MySqlParserINDEXES, MySqlParserINITIAL_SIZE, MySqlParserINPLACE, MySqlParserINSERT_METHOD, MySqlParserINSTALL, MySqlParserINSTANCE, MySqlParserINSTANT, MySqlParserINVISIBLE, MySqlParserINVOKER, MySqlParserIO, MySqlParserIO_THREAD, MySqlParserIPC, MySqlParserISOLATION, MySqlParserISSUER, MySqlParserJSON, MySqlParserKEY_BLOCK_SIZE, MySqlParserLANGUAGE, MySqlParserLAST, MySqlParserLEAVES, MySqlParserLESS, MySqlParserLEVEL, MySqlParserLIST, MySqlParserLOCAL, MySqlParserLOGFILE, MySqlParserLOGS, MySqlParserMASTER, MySqlParserMASTER_AUTO_POSITION, MySqlParserMASTER_CONNECT_RETRY, MySqlParserMASTER_DELAY, MySqlParserMASTER_HEARTBEAT_PERIOD, MySqlParserMASTER_HOST, MySqlParserMASTER_LOG_FILE, MySqlParserMASTER_LOG_POS, MySqlParserMASTER_PASSWORD, MySqlParserMASTER_PORT, MySqlParserMASTER_RETRY_COUNT, MySqlParserMASTER_SSL, MySqlParserMASTER_SSL_CA, MySqlParserMASTER_SSL_CAPATH, MySqlParserMASTER_SSL_CERT, MySqlParserMASTER_SSL_CIPHER, MySqlParserMASTER_SSL_CRL, MySqlParserMASTER_SSL_CRLPATH, MySqlParserMASTER_SSL_KEY, MySqlParserMASTER_TLS_VERSION, MySqlParserMASTER_USER, MySqlParserMAX_CONNECTIONS_PER_HOUR, MySqlParserMAX_QUERIES_PER_HOUR, MySqlParserMAX_ROWS, MySqlParserMAX_SIZE, MySqlParserMAX_UPDATES_PER_HOUR, MySqlParserMAX_USER_CONNECTIONS, MySqlParserMEDIUM, MySqlParserMEMBER, MySqlParserMERGE, MySqlParserMESSAGE_TEXT, MySqlParserMID, MySqlParserMIGRATE, MySqlParserMIN_ROWS, MySqlParserMODE, MySqlParserMODIFY, MySqlParserMUTEX, MySqlParserMYSQL, MySqlParserMYSQL_ERRNO, MySqlParserNAME, MySqlParserNAMES, MySqlParserNCHAR, MySqlParserNEVER, MySqlParserNEXT, MySqlParserNO, MySqlParserNOCOPY, MySqlParserNOWAIT, MySqlParserNODEGROUP, MySqlParserNONE, MySqlParserODBC, MySqlParserOFFLINE, MySqlParserOFFSET, MySqlParserOF, MySqlParserOJ, MySqlParserOLD_PASSWORD, MySqlParserONE, MySqlParserONLINE, MySqlParserONLY, MySqlParserOPEN, MySqlParserOPTIMIZER_COSTS, MySqlParserOPTIONS, MySqlParserOWNER, MySqlParserPACK_KEYS, MySqlParserPAGE, MySqlParserPARSER, MySqlParserPARTIAL, MySqlParserPARTITIONING, MySqlParserPARTITIONS, MySqlParserPASSWORD, MySqlParserPASSWORD_LOCK_TIME, MySqlParserPHASE, MySqlParserPLUGIN, MySqlParserPLUGIN_DIR, MySqlParserPLUGINS, MySqlParserPORT, MySqlParserPRECEDES, MySqlParserPREPARE, MySqlParserPRESERVE, MySqlParserPREV, MySqlParserPROCESSLIST, MySqlParserPROFILE, MySqlParserPROFILES, MySqlParserPROXY, MySqlParserQUERY, MySqlParserQUICK, MySqlParserREBUILD, MySqlParserRECOVER, MySqlParserRECURSIVE, MySqlParserREDO_BUFFER_SIZE, MySqlParserREDUNDANT, MySqlParserRELAY, MySqlParserRELAY_LOG_FILE, MySqlParserRELAY_LOG_POS, MySqlParserRELAYLOG, MySqlParserREMOVE, MySqlParserREORGANIZE, MySqlParserREPAIR, MySqlParserREPLICATE_DO_DB, MySqlParserREPLICATE_DO_TABLE, MySqlParserREPLICATE_IGNORE_DB, MySqlParserREPLICATE_IGNORE_TABLE, MySqlParserREPLICATE_REWRITE_DB, MySqlParserREPLICATE_WILD_DO_TABLE, MySqlParserREPLICATE_WILD_IGNORE_TABLE, MySqlParserREPLICATION, MySqlParserRESET, MySqlParserRESUME, MySqlParserRETURNED_SQLSTATE, MySqlParserRETURNING, MySqlParserRETURNS, MySqlParserREUSE, MySqlParserROLE, MySqlParserROLLBACK, MySqlParserROLLUP, MySqlParserROTATE, MySqlParserROW, MySqlParserROWS, MySqlParserROW_FORMAT, MySqlParserRTREE, MySqlParserSAVEPOINT, MySqlParserSCHEDULE, MySqlParserSECURITY, MySqlParserSERVER, MySqlParserSESSION, MySqlParserSHARE, MySqlParserSHARED, MySqlParserSIGNED, MySqlParserSIMPLE, MySqlParserSLAVE, MySqlParserSLOW, MySqlParserSNAPSHOT, MySqlParserSOCKET, MySqlParserSOME, MySqlParserSONAME, MySqlParserSOUNDS, MySqlParserSOURCE, MySqlParserSQL_AFTER_GTIDS, MySqlParserSQL_AFTER_MTS_GAPS, MySqlParserSQL_BEFORE_GTIDS, MySqlParserSQL_BUFFER_RESULT, MySqlParserSQL_CACHE, MySqlParserSQL_NO_CACHE, MySqlParserSQL_THREAD, MySqlParserSTART, MySqlParserSTARTS, MySqlParserSTATS_AUTO_RECALC, MySqlParserSTATS_PERSISTENT, MySqlParserSTATS_SAMPLE_PAGES, MySqlParserSTATUS, MySqlParserSTOP, MySqlParserSTORAGE, MySqlParserSTRING, MySqlParserSUBCLASS_ORIGIN, MySqlParserSUBJECT, MySqlParserSUBPARTITION, MySqlParserSUBPARTITIONS, MySqlParserSUSPEND, MySqlParserSWAPS, MySqlParserSWITCHES, MySqlParserTABLE_NAME, MySqlParserTABLESPACE, MySqlParserTABLE_TYPE, MySqlParserTEMPORARY, MySqlParserTEMPTABLE, MySqlParserTHAN, MySqlParserTRADITIONAL, MySqlParserTRANSACTION, MySqlParserTRANSACTIONAL, MySqlParserTRIGGERS, MySqlParserTRUNCATE, MySqlParserUNBOUNDED, MySqlParserUNDEFINED, MySqlParserUNDOFILE, MySqlParserUNDO_BUFFER_SIZE, MySqlParserUNINSTALL, MySqlParserUNKNOWN, MySqlParserUNTIL, MySqlParserUPGRADE, MySqlParserUSER, MySqlParserUSE_FRM, MySqlParserUSER_RESOURCES, MySqlParserVALIDATION, MySqlParserVALUE, MySqlParserVARIABLES, MySqlParserVIEW, MySqlParserVIRTUAL, MySqlParserVISIBLE, MySqlParserWAIT, MySqlParserWARNINGS, MySqlParserWITHOUT, MySqlParserWORK, MySqlParserWRAPPER, MySqlParserX509, MySqlParserXA, MySqlParserXML, MySqlParserYES, MySqlParserEUR, MySqlParserUSA, MySqlParserJIS, MySqlParserISO, MySqlParserINTERNAL, MySqlParserQUARTER, MySqlParserMONTH, MySqlParserDAY, MySqlParserHOUR, MySqlParserMINUTE, MySqlParserWEEK, MySqlParserSECOND, MySqlParserMICROSECOND, MySqlParserADMIN, MySqlParserAUDIT_ABORT_EXEMPT, MySqlParserAUDIT_ADMIN, MySqlParserAUTHENTICATION_POLICY_ADMIN, MySqlParserBACKUP_ADMIN, MySqlParserBINLOG_ADMIN, MySqlParserBINLOG_ENCRYPTION_ADMIN, MySqlParserCLONE_ADMIN, MySqlParserCONNECTION_ADMIN, MySqlParserENCRYPTION_KEY_ADMIN, MySqlParserEXECUTE, MySqlParserFILE, MySqlParserFIREWALL_ADMIN, MySqlParserFIREWALL_EXEMPT, MySqlParserFIREWALL_USER, MySqlParserGROUP_REPLICATION_ADMIN, MySqlParserINNODB_REDO_LOG_ARCHIVE, MySqlParserINVOKE, MySqlParserLAMBDA, MySqlParserNDB_STORED_USER, MySqlParserPASSWORDLESS_USER_ADMIN, MySqlParserPERSIST_RO_VARIABLES_ADMIN, MySqlParserPRIVILEGES, MySqlParserPROCESS, MySqlParserRELOAD, MySqlParserREPLICATION_APPLIER, MySqlParserREPLICATION_SLAVE_ADMIN, MySqlParserRESOURCE_GROUP_ADMIN, MySqlParserRESOURCE_GROUP_USER, MySqlParserROLE_ADMIN, MySqlParserROUTINE, MySqlParserS3, MySqlParserSESSION_VARIABLES_ADMIN, MySqlParserSET_USER_ID, MySqlParserSHOW_ROUTINE, MySqlParserSHUTDOWN, MySqlParserSUPER, MySqlParserSYSTEM_VARIABLES_ADMIN, MySqlParserTABLES, MySqlParserTABLE_ENCRYPTION_ADMIN, MySqlParserVERSION_TOKEN_ADMIN, MySqlParserXA_RECOVER_ADMIN, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserARCHIVE, MySqlParserBLACKHOLE, MySqlParserCSV, MySqlParserFEDERATED, MySqlParserINNODB, MySqlParserMEMORY, MySqlParserMRG_MYISAM, MySqlParserMYISAM, MySqlParserNDB, MySqlParserNDBCLUSTER, MySqlParserPERFORMANCE_SCHEMA, MySqlParserTOKUDB, MySqlParserREPEATABLE, MySqlParserCOMMITTED, MySqlParserUNCOMMITTED, MySqlParserSERIALIZABLE, MySqlParserGEOMETRYCOLLECTION, MySqlParserLINESTRING, MySqlParserMULTILINESTRING, MySqlParserMULTIPOINT, MySqlParserMULTIPOLYGON, MySqlParserPOINT, MySqlParserPOLYGON, MySqlParserABS, MySqlParserACOS, MySqlParserADDDATE, MySqlParserADDTIME, MySqlParserAES_DECRYPT, MySqlParserAES_ENCRYPT, MySqlParserAREA, MySqlParserASBINARY, MySqlParserASIN, MySqlParserASTEXT, MySqlParserASWKB, MySqlParserASWKT, MySqlParserASYMMETRIC_DECRYPT, MySqlParserASYMMETRIC_DERIVE, MySqlParserASYMMETRIC_ENCRYPT, MySqlParserASYMMETRIC_SIGN, MySqlParserASYMMETRIC_VERIFY, MySqlParserATAN, MySqlParserATAN2, MySqlParserBENCHMARK, MySqlParserBIN, MySqlParserBIT_COUNT, MySqlParserBIT_LENGTH, MySqlParserBUFFER, MySqlParserCATALOG_NAME, MySqlParserCEIL, MySqlParserCEILING, MySqlParserCENTROID, MySqlParserCHARACTER_LENGTH, MySqlParserCHARSET, MySqlParserCHAR_LENGTH, MySqlParserCOERCIBILITY, MySqlParserCOLLATION, MySqlParserCOMPRESS, MySqlParserCONCAT, MySqlParserCONCAT_WS, MySqlParserCONNECTION_ID, MySqlParserCONV, MySqlParserCONVERT_TZ, MySqlParserCOS, MySqlParserCOT, MySqlParserCRC32, MySqlParserCREATE_ASYMMETRIC_PRIV_KEY, MySqlParserCREATE_ASYMMETRIC_PUB_KEY, MySqlParserCREATE_DH_PARAMETERS, MySqlParserCREATE_DIGEST, MySqlParserCROSSES, MySqlParserDATEDIFF, MySqlParserDATE_FORMAT, MySqlParserDAYNAME, MySqlParserDAYOFMONTH, MySqlParserDAYOFWEEK, MySqlParserDAYOFYEAR, MySqlParserDECODE, MySqlParserDEGREES, MySqlParserDES_DECRYPT, MySqlParserDES_ENCRYPT, MySqlParserDIMENSION, MySqlParserDISJOINT, MySqlParserDISTANCE, MySqlParserELT, MySqlParserENCODE, MySqlParserENCRYPT, MySqlParserENDPOINT, MySqlParserENGINE_ATTRIBUTE, MySqlParserENVELOPE, MySqlParserEQUALS, MySqlParserEXP, MySqlParserEXPORT_SET, MySqlParserEXTERIORRING, MySqlParserEXTRACTVALUE, MySqlParserFIELD, MySqlParserFIND_IN_SET, MySqlParserFLOOR, MySqlParserFORMAT, MySqlParserFOUND_ROWS, MySqlParserFROM_BASE64, MySqlParserFROM_DAYS, MySqlParserFROM_UNIXTIME, MySqlParserGEOMCOLLFROMTEXT, MySqlParserGEOMCOLLFROMWKB, MySqlParserGEOMETRYCOLLECTIONFROMTEXT, MySqlParserGEOMETRYCOLLECTIONFROMWKB, MySqlParserGEOMETRYFROMTEXT, MySqlParserGEOMETRYFROMWKB, MySqlParserGEOMETRYN, MySqlParserGEOMETRYTYPE, MySqlParserGEOMFROMTEXT, MySqlParserGEOMFROMWKB, MySqlParserGET_FORMAT, MySqlParserGET_LOCK, MySqlParserGLENGTH, MySqlParserGREATEST, MySqlParserGTID_SUBSET, MySqlParserGTID_SUBTRACT, MySqlParserHEX, MySqlParserIFNULL, MySqlParserINET6_ATON, MySqlParserINET6_NTOA, MySqlParserINET_ATON, MySqlParserINET_NTOA, MySqlParserINSTR, MySqlParserINTERIORRINGN, MySqlParserINTERSECTS, MySqlParserISCLOSED, MySqlParserISEMPTY, MySqlParserISNULL, MySqlParserISSIMPLE, MySqlParserIS_FREE_LOCK, MySqlParserIS_IPV4, MySqlParserIS_IPV4_COMPAT, MySqlParserIS_IPV4_MAPPED, MySqlParserIS_IPV6, MySqlParserIS_USED_LOCK, MySqlParserLAST_INSERT_ID, MySqlParserLCASE, MySqlParserLEAST, MySqlParserLENGTH, MySqlParserLINEFROMTEXT, MySqlParserLINEFROMWKB, MySqlParserLINESTRINGFROMTEXT, MySqlParserLINESTRINGFROMWKB, MySqlParserLN, MySqlParserLOAD_FILE, MySqlParserLOCATE, MySqlParserLOG, MySqlParserLOG10, MySqlParserLOG2, MySqlParserLOWER, MySqlParserLPAD, MySqlParserLTRIM, MySqlParserMAKEDATE, MySqlParserMAKETIME, MySqlParserMAKE_SET, MySqlParserMASTER_POS_WAIT, MySqlParserMBRCONTAINS, MySqlParserMBRDISJOINT, MySqlParserMBREQUAL, MySqlParserMBRINTERSECTS, MySqlParserMBROVERLAPS, MySqlParserMBRTOUCHES, MySqlParserMBRWITHIN, MySqlParserMD5, MySqlParserMLINEFROMTEXT, MySqlParserMLINEFROMWKB, MySqlParserMONTHNAME, MySqlParserMPOINTFROMTEXT, MySqlParserMPOINTFROMWKB, MySqlParserMPOLYFROMTEXT, MySqlParserMPOLYFROMWKB, MySqlParserMULTILINESTRINGFROMTEXT, MySqlParserMULTILINESTRINGFROMWKB, MySqlParserMULTIPOINTFROMTEXT, MySqlParserMULTIPOINTFROMWKB, MySqlParserMULTIPOLYGONFROMTEXT, MySqlParserMULTIPOLYGONFROMWKB, MySqlParserNAME_CONST, MySqlParserNULLIF, MySqlParserNUMGEOMETRIES, MySqlParserNUMINTERIORRINGS, MySqlParserNUMPOINTS, MySqlParserOCT, MySqlParserOCTET_LENGTH, MySqlParserORD, MySqlParserOVERLAPS, MySqlParserPERIOD_ADD, MySqlParserPERIOD_DIFF, MySqlParserPI, MySqlParserPOINTFROMTEXT, MySqlParserPOINTFROMWKB, MySqlParserPOINTN, MySqlParserPOLYFROMTEXT, MySqlParserPOLYFROMWKB, MySqlParserPOLYGONFROMTEXT, MySqlParserPOLYGONFROMWKB, MySqlParserPOW, MySqlParserPOWER, MySqlParserQUOTE, MySqlParserRADIANS, MySqlParserRAND, MySqlParserRANDOM, MySqlParserRANDOM_BYTES, MySqlParserRELEASE_LOCK, MySqlParserREVERSE, MySqlParserROUND, MySqlParserROW_COUNT, MySqlParserRPAD, MySqlParserRTRIM, MySqlParserSEC_TO_TIME, MySqlParserSECONDARY_ENGINE_ATTRIBUTE, MySqlParserSESSION_USER, MySqlParserSHA, MySqlParserSHA1, MySqlParserSHA2, MySqlParserSCHEMA_NAME, MySqlParserSIGN, MySqlParserSIN, MySqlParserSLEEP, MySqlParserSOUNDEX, MySqlParserSQL_THREAD_WAIT_AFTER_GTIDS, MySqlParserSQRT, MySqlParserSRID, MySqlParserSTARTPOINT, MySqlParserSTRCMP, MySqlParserSTR_TO_DATE, MySqlParserST_AREA, MySqlParserST_ASBINARY, MySqlParserST_ASTEXT, MySqlParserST_ASWKB, MySqlParserST_ASWKT, MySqlParserST_BUFFER, MySqlParserST_CENTROID, MySqlParserST_CONTAINS, MySqlParserST_CROSSES, MySqlParserST_DIFFERENCE, MySqlParserST_DIMENSION, MySqlParserST_DISJOINT, MySqlParserST_DISTANCE, MySqlParserST_ENDPOINT, MySqlParserST_ENVELOPE, MySqlParserST_EQUALS, MySqlParserST_EXTERIORRING, MySqlParserST_GEOMCOLLFROMTEXT, MySqlParserST_GEOMCOLLFROMTXT, MySqlParserST_GEOMCOLLFROMWKB, MySqlParserST_GEOMETRYCOLLECTIONFROMTEXT, MySqlParserST_GEOMETRYCOLLECTIONFROMWKB, MySqlParserST_GEOMETRYFROMTEXT, MySqlParserST_GEOMETRYFROMWKB, MySqlParserST_GEOMETRYN, MySqlParserST_GEOMETRYTYPE, MySqlParserST_GEOMFROMTEXT, MySqlParserST_GEOMFROMWKB, MySqlParserST_INTERIORRINGN, MySqlParserST_INTERSECTION, MySqlParserST_INTERSECTS, MySqlParserST_ISCLOSED, MySqlParserST_ISEMPTY, MySqlParserST_ISSIMPLE, MySqlParserST_LINEFROMTEXT, MySqlParserST_LINEFROMWKB, MySqlParserST_LINESTRINGFROMTEXT, MySqlParserST_LINESTRINGFROMWKB, MySqlParserST_NUMGEOMETRIES, MySqlParserST_NUMINTERIORRING, MySqlParserST_NUMINTERIORRINGS, MySqlParserST_NUMPOINTS, MySqlParserST_OVERLAPS, MySqlParserST_POINTFROMTEXT, MySqlParserST_POINTFROMWKB, MySqlParserST_POINTN, MySqlParserST_POLYFROMTEXT, MySqlParserST_POLYFROMWKB, MySqlParserST_POLYGONFROMTEXT, MySqlParserST_POLYGONFROMWKB, MySqlParserST_SRID, MySqlParserST_STARTPOINT, MySqlParserST_SYMDIFFERENCE, MySqlParserST_TOUCHES, MySqlParserST_UNION, MySqlParserST_WITHIN, MySqlParserST_X, MySqlParserST_Y, MySqlParserSTRING_TO_VECTOR, MySqlParserSUBDATE, MySqlParserSUBSTRING_INDEX, MySqlParserSUBTIME, MySqlParserSYSTEM_USER, MySqlParserTAN, MySqlParserTIMEDIFF, MySqlParserTIMESTAMPADD, MySqlParserTIMESTAMPDIFF, MySqlParserTIME_FORMAT, MySqlParserTIME_TO_SEC, MySqlParserTOUCHES, MySqlParserTO_BASE64, MySqlParserTO_DAYS, MySqlParserTO_SECONDS, MySqlParserTP_CONNECTION_ADMIN, MySqlParserUCASE, MySqlParserUNCOMPRESS, MySqlParserUNCOMPRESSED_LENGTH, MySqlParserUNHEX, MySqlParserUNIX_TIMESTAMP, MySqlParserUPDATEXML, MySqlParserUPPER, MySqlParserUUID, MySqlParserUUID_SHORT, MySqlParserVALIDATE_PASSWORD_STRENGTH, MySqlParserVECTOR_DIM, MySqlParserVECTOR_TO_STRING, MySqlParserVERSION, MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS, MySqlParserWEEKDAY, MySqlParserWEEKOFYEAR, MySqlParserWEIGHT_STRING, MySqlParserWITHIN, MySqlParserYEARWEEK, MySqlParserY_FUNCTION, MySqlParserX_FUNCTION, MySqlParserMOD, MySqlParserCHARSET_REVERSE_QOUTE_STRING, MySqlParserSTRING_LITERAL, MySqlParserID: + { + p.SetState(2969) + p.UidList() + } + + case MySqlParserALL: + { + p.SetState(2970) + p.Match(MySqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case MySqlParserREPAIR: + localctx = NewAlterByRepairPartitionContext(p, localctx) + p.EnterOuterAlt(localctx, 13) + { + p.SetState(2973) + p.Match(MySqlParserREPAIR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2974) + p.Match(MySqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2977) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserARRAY, MySqlParserATTRIBUTE, MySqlParserBUCKETS, MySqlParserCONDITION, MySqlParserCURRENT, MySqlParserCURRENT_USER, MySqlParserDATABASE, MySqlParserDEFAULT, MySqlParserDIAGNOSTICS, MySqlParserEMPTY, MySqlParserENFORCED, MySqlParserEXCEPT, MySqlParserGROUP, MySqlParserIF, MySqlParserIGNORED, MySqlParserINSERT, MySqlParserLATERAL, MySqlParserLEFT, MySqlParserNUMBER, MySqlParserOPTIONAL, MySqlParserORDER, MySqlParserPRIMARY, MySqlParserREPEAT, MySqlParserREPLACE, MySqlParserRIGHT, MySqlParserSCHEMA, MySqlParserSKIP_QUERY_REWRITE, MySqlParserSTACKED, MySqlParserSTATEMENT, MySqlParserDATE, MySqlParserTIME, MySqlParserTIMESTAMP, MySqlParserDATETIME, MySqlParserYEAR, MySqlParserBINARY, MySqlParserTEXT, MySqlParserENUM, MySqlParserSERIAL, MySqlParserJSON_ARRAY, MySqlParserJSON_ARRAYAGG, MySqlParserJSON_ARRAY_APPEND, MySqlParserJSON_ARRAY_INSERT, MySqlParserJSON_CONTAINS, MySqlParserJSON_CONTAINS_PATH, MySqlParserJSON_DEPTH, MySqlParserJSON_EXTRACT, MySqlParserJSON_INSERT, MySqlParserJSON_KEYS, MySqlParserJSON_LENGTH, MySqlParserJSON_MERGE, MySqlParserJSON_MERGE_PATCH, MySqlParserJSON_MERGE_PRESERVE, MySqlParserJSON_OBJECT, MySqlParserJSON_OBJECTAGG, MySqlParserJSON_OVERLAPS, MySqlParserJSON_PRETTY, MySqlParserJSON_QUOTE, MySqlParserJSON_REMOVE, MySqlParserJSON_REPLACE, MySqlParserJSON_SCHEMA_VALID, MySqlParserJSON_SCHEMA_VALIDATION_REPORT, MySqlParserJSON_SEARCH, MySqlParserJSON_SET, MySqlParserJSON_STORAGE_FREE, MySqlParserJSON_STORAGE_SIZE, MySqlParserJSON_TABLE, MySqlParserJSON_TYPE, MySqlParserJSON_UNQUOTE, MySqlParserJSON_VALID, MySqlParserJSON_VALUE, MySqlParserNESTED, MySqlParserORDINALITY, MySqlParserPATH, MySqlParserAVG, MySqlParserBIT_AND, MySqlParserBIT_OR, MySqlParserBIT_XOR, MySqlParserCOUNT, MySqlParserCUME_DIST, MySqlParserDENSE_RANK, MySqlParserFIRST_VALUE, MySqlParserGROUP_CONCAT, MySqlParserLAG, MySqlParserLAST_VALUE, MySqlParserLEAD, MySqlParserMAX, MySqlParserMIN, MySqlParserNTILE, MySqlParserNTH_VALUE, MySqlParserPERCENT_RANK, MySqlParserRANK, MySqlParserROW_NUMBER, MySqlParserSTD, MySqlParserSTDDEV, MySqlParserSTDDEV_POP, MySqlParserSTDDEV_SAMP, MySqlParserSUM, MySqlParserVAR_POP, MySqlParserVAR_SAMP, MySqlParserVARIANCE, MySqlParserCURRENT_DATE, MySqlParserCURRENT_TIME, MySqlParserCURRENT_TIMESTAMP, MySqlParserLOCALTIME, MySqlParserCURDATE, MySqlParserCURTIME, MySqlParserDATE_ADD, MySqlParserDATE_SUB, MySqlParserLOCALTIMESTAMP, MySqlParserNOW, MySqlParserPOSITION, MySqlParserSUBSTR, MySqlParserSUBSTRING, MySqlParserSYSDATE, MySqlParserTRIM, MySqlParserUTC_DATE, MySqlParserUTC_TIME, MySqlParserUTC_TIMESTAMP, MySqlParserACCOUNT, MySqlParserACTION, MySqlParserAFTER, MySqlParserAGGREGATE, MySqlParserALGORITHM, MySqlParserANY, MySqlParserAT, MySqlParserAUTHORS, MySqlParserAUTOCOMMIT, MySqlParserAUTOEXTEND_SIZE, MySqlParserAUTO_INCREMENT, MySqlParserAVG_ROW_LENGTH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserBIT, MySqlParserBLOCK, MySqlParserBOOL, MySqlParserBOOLEAN, MySqlParserBTREE, MySqlParserCACHE, MySqlParserCASCADED, MySqlParserCHAIN, MySqlParserCHANGED, MySqlParserCHANNEL, MySqlParserCHECKSUM, MySqlParserPAGE_CHECKSUM, MySqlParserCIPHER, MySqlParserCLASS_ORIGIN, MySqlParserCLIENT, MySqlParserCLOSE, MySqlParserCLUSTERING, MySqlParserCOALESCE, MySqlParserCODE, MySqlParserCOLUMNS, MySqlParserCOLUMN_FORMAT, MySqlParserCOLUMN_NAME, MySqlParserCOMMENT, MySqlParserCOMMIT, MySqlParserCOMPACT, MySqlParserCOMPLETION, MySqlParserCOMPRESSED, MySqlParserCOMPRESSION, MySqlParserCONCURRENT, MySqlParserCONNECT, MySqlParserCONNECTION, MySqlParserCONSISTENT, MySqlParserCONSTRAINT_CATALOG, MySqlParserCONSTRAINT_SCHEMA, MySqlParserCONSTRAINT_NAME, MySqlParserCONTAINS, MySqlParserCONTEXT, MySqlParserCONTRIBUTORS, MySqlParserCOPY, MySqlParserCPU, MySqlParserCURSOR_NAME, MySqlParserDATA, MySqlParserDATAFILE, MySqlParserDEALLOCATE, MySqlParserDEFAULT_AUTH, MySqlParserDEFINER, MySqlParserDELAY_KEY_WRITE, MySqlParserDES_KEY_FILE, MySqlParserDIRECTORY, MySqlParserDISABLE, MySqlParserDISCARD, MySqlParserDISK, MySqlParserDO, MySqlParserDUMPFILE, MySqlParserDUPLICATE, MySqlParserDYNAMIC, MySqlParserENABLE, MySqlParserENCRYPTION, MySqlParserEND, MySqlParserENDS, MySqlParserENGINE, MySqlParserENGINES, MySqlParserERROR, MySqlParserERRORS, MySqlParserESCAPE, MySqlParserEVEN, MySqlParserEVENT, MySqlParserEVENTS, MySqlParserEVERY, MySqlParserEXCHANGE, MySqlParserEXCLUSIVE, MySqlParserEXPIRE, MySqlParserEXPORT, MySqlParserEXTENDED, MySqlParserEXTENT_SIZE, MySqlParserFAILED_LOGIN_ATTEMPTS, MySqlParserFAST, MySqlParserFAULTS, MySqlParserFIELDS, MySqlParserFILE_BLOCK_SIZE, MySqlParserFILTER, MySqlParserFIRST, MySqlParserFIXED, MySqlParserFLUSH, MySqlParserFOLLOWS, MySqlParserFOUND, MySqlParserFULL, MySqlParserFUNCTION, MySqlParserGENERAL, MySqlParserGLOBAL, MySqlParserGRANTS, MySqlParserGROUP_REPLICATION, MySqlParserHANDLER, MySqlParserHASH, MySqlParserHELP, MySqlParserHISTORY, MySqlParserHOST, MySqlParserHOSTS, MySqlParserIDENTIFIED, MySqlParserIGNORE_SERVER_IDS, MySqlParserIMPORT, MySqlParserINDEXES, MySqlParserINITIAL_SIZE, MySqlParserINPLACE, MySqlParserINSERT_METHOD, MySqlParserINSTALL, MySqlParserINSTANCE, MySqlParserINSTANT, MySqlParserINVISIBLE, MySqlParserINVOKER, MySqlParserIO, MySqlParserIO_THREAD, MySqlParserIPC, MySqlParserISOLATION, MySqlParserISSUER, MySqlParserJSON, MySqlParserKEY_BLOCK_SIZE, MySqlParserLANGUAGE, MySqlParserLAST, MySqlParserLEAVES, MySqlParserLESS, MySqlParserLEVEL, MySqlParserLIST, MySqlParserLOCAL, MySqlParserLOGFILE, MySqlParserLOGS, MySqlParserMASTER, MySqlParserMASTER_AUTO_POSITION, MySqlParserMASTER_CONNECT_RETRY, MySqlParserMASTER_DELAY, MySqlParserMASTER_HEARTBEAT_PERIOD, MySqlParserMASTER_HOST, MySqlParserMASTER_LOG_FILE, MySqlParserMASTER_LOG_POS, MySqlParserMASTER_PASSWORD, MySqlParserMASTER_PORT, MySqlParserMASTER_RETRY_COUNT, MySqlParserMASTER_SSL, MySqlParserMASTER_SSL_CA, MySqlParserMASTER_SSL_CAPATH, MySqlParserMASTER_SSL_CERT, MySqlParserMASTER_SSL_CIPHER, MySqlParserMASTER_SSL_CRL, MySqlParserMASTER_SSL_CRLPATH, MySqlParserMASTER_SSL_KEY, MySqlParserMASTER_TLS_VERSION, MySqlParserMASTER_USER, MySqlParserMAX_CONNECTIONS_PER_HOUR, MySqlParserMAX_QUERIES_PER_HOUR, MySqlParserMAX_ROWS, MySqlParserMAX_SIZE, MySqlParserMAX_UPDATES_PER_HOUR, MySqlParserMAX_USER_CONNECTIONS, MySqlParserMEDIUM, MySqlParserMEMBER, MySqlParserMERGE, MySqlParserMESSAGE_TEXT, MySqlParserMID, MySqlParserMIGRATE, MySqlParserMIN_ROWS, MySqlParserMODE, MySqlParserMODIFY, MySqlParserMUTEX, MySqlParserMYSQL, MySqlParserMYSQL_ERRNO, MySqlParserNAME, MySqlParserNAMES, MySqlParserNCHAR, MySqlParserNEVER, MySqlParserNEXT, MySqlParserNO, MySqlParserNOCOPY, MySqlParserNOWAIT, MySqlParserNODEGROUP, MySqlParserNONE, MySqlParserODBC, MySqlParserOFFLINE, MySqlParserOFFSET, MySqlParserOF, MySqlParserOJ, MySqlParserOLD_PASSWORD, MySqlParserONE, MySqlParserONLINE, MySqlParserONLY, MySqlParserOPEN, MySqlParserOPTIMIZER_COSTS, MySqlParserOPTIONS, MySqlParserOWNER, MySqlParserPACK_KEYS, MySqlParserPAGE, MySqlParserPARSER, MySqlParserPARTIAL, MySqlParserPARTITIONING, MySqlParserPARTITIONS, MySqlParserPASSWORD, MySqlParserPASSWORD_LOCK_TIME, MySqlParserPHASE, MySqlParserPLUGIN, MySqlParserPLUGIN_DIR, MySqlParserPLUGINS, MySqlParserPORT, MySqlParserPRECEDES, MySqlParserPREPARE, MySqlParserPRESERVE, MySqlParserPREV, MySqlParserPROCESSLIST, MySqlParserPROFILE, MySqlParserPROFILES, MySqlParserPROXY, MySqlParserQUERY, MySqlParserQUICK, MySqlParserREBUILD, MySqlParserRECOVER, MySqlParserRECURSIVE, MySqlParserREDO_BUFFER_SIZE, MySqlParserREDUNDANT, MySqlParserRELAY, MySqlParserRELAY_LOG_FILE, MySqlParserRELAY_LOG_POS, MySqlParserRELAYLOG, MySqlParserREMOVE, MySqlParserREORGANIZE, MySqlParserREPAIR, MySqlParserREPLICATE_DO_DB, MySqlParserREPLICATE_DO_TABLE, MySqlParserREPLICATE_IGNORE_DB, MySqlParserREPLICATE_IGNORE_TABLE, MySqlParserREPLICATE_REWRITE_DB, MySqlParserREPLICATE_WILD_DO_TABLE, MySqlParserREPLICATE_WILD_IGNORE_TABLE, MySqlParserREPLICATION, MySqlParserRESET, MySqlParserRESUME, MySqlParserRETURNED_SQLSTATE, MySqlParserRETURNING, MySqlParserRETURNS, MySqlParserREUSE, MySqlParserROLE, MySqlParserROLLBACK, MySqlParserROLLUP, MySqlParserROTATE, MySqlParserROW, MySqlParserROWS, MySqlParserROW_FORMAT, MySqlParserRTREE, MySqlParserSAVEPOINT, MySqlParserSCHEDULE, MySqlParserSECURITY, MySqlParserSERVER, MySqlParserSESSION, MySqlParserSHARE, MySqlParserSHARED, MySqlParserSIGNED, MySqlParserSIMPLE, MySqlParserSLAVE, MySqlParserSLOW, MySqlParserSNAPSHOT, MySqlParserSOCKET, MySqlParserSOME, MySqlParserSONAME, MySqlParserSOUNDS, MySqlParserSOURCE, MySqlParserSQL_AFTER_GTIDS, MySqlParserSQL_AFTER_MTS_GAPS, MySqlParserSQL_BEFORE_GTIDS, MySqlParserSQL_BUFFER_RESULT, MySqlParserSQL_CACHE, MySqlParserSQL_NO_CACHE, MySqlParserSQL_THREAD, MySqlParserSTART, MySqlParserSTARTS, MySqlParserSTATS_AUTO_RECALC, MySqlParserSTATS_PERSISTENT, MySqlParserSTATS_SAMPLE_PAGES, MySqlParserSTATUS, MySqlParserSTOP, MySqlParserSTORAGE, MySqlParserSTRING, MySqlParserSUBCLASS_ORIGIN, MySqlParserSUBJECT, MySqlParserSUBPARTITION, MySqlParserSUBPARTITIONS, MySqlParserSUSPEND, MySqlParserSWAPS, MySqlParserSWITCHES, MySqlParserTABLE_NAME, MySqlParserTABLESPACE, MySqlParserTABLE_TYPE, MySqlParserTEMPORARY, MySqlParserTEMPTABLE, MySqlParserTHAN, MySqlParserTRADITIONAL, MySqlParserTRANSACTION, MySqlParserTRANSACTIONAL, MySqlParserTRIGGERS, MySqlParserTRUNCATE, MySqlParserUNBOUNDED, MySqlParserUNDEFINED, MySqlParserUNDOFILE, MySqlParserUNDO_BUFFER_SIZE, MySqlParserUNINSTALL, MySqlParserUNKNOWN, MySqlParserUNTIL, MySqlParserUPGRADE, MySqlParserUSER, MySqlParserUSE_FRM, MySqlParserUSER_RESOURCES, MySqlParserVALIDATION, MySqlParserVALUE, MySqlParserVARIABLES, MySqlParserVIEW, MySqlParserVIRTUAL, MySqlParserVISIBLE, MySqlParserWAIT, MySqlParserWARNINGS, MySqlParserWITHOUT, MySqlParserWORK, MySqlParserWRAPPER, MySqlParserX509, MySqlParserXA, MySqlParserXML, MySqlParserYES, MySqlParserEUR, MySqlParserUSA, MySqlParserJIS, MySqlParserISO, MySqlParserINTERNAL, MySqlParserQUARTER, MySqlParserMONTH, MySqlParserDAY, MySqlParserHOUR, MySqlParserMINUTE, MySqlParserWEEK, MySqlParserSECOND, MySqlParserMICROSECOND, MySqlParserADMIN, MySqlParserAUDIT_ABORT_EXEMPT, MySqlParserAUDIT_ADMIN, MySqlParserAUTHENTICATION_POLICY_ADMIN, MySqlParserBACKUP_ADMIN, MySqlParserBINLOG_ADMIN, MySqlParserBINLOG_ENCRYPTION_ADMIN, MySqlParserCLONE_ADMIN, MySqlParserCONNECTION_ADMIN, MySqlParserENCRYPTION_KEY_ADMIN, MySqlParserEXECUTE, MySqlParserFILE, MySqlParserFIREWALL_ADMIN, MySqlParserFIREWALL_EXEMPT, MySqlParserFIREWALL_USER, MySqlParserGROUP_REPLICATION_ADMIN, MySqlParserINNODB_REDO_LOG_ARCHIVE, MySqlParserINVOKE, MySqlParserLAMBDA, MySqlParserNDB_STORED_USER, MySqlParserPASSWORDLESS_USER_ADMIN, MySqlParserPERSIST_RO_VARIABLES_ADMIN, MySqlParserPRIVILEGES, MySqlParserPROCESS, MySqlParserRELOAD, MySqlParserREPLICATION_APPLIER, MySqlParserREPLICATION_SLAVE_ADMIN, MySqlParserRESOURCE_GROUP_ADMIN, MySqlParserRESOURCE_GROUP_USER, MySqlParserROLE_ADMIN, MySqlParserROUTINE, MySqlParserS3, MySqlParserSESSION_VARIABLES_ADMIN, MySqlParserSET_USER_ID, MySqlParserSHOW_ROUTINE, MySqlParserSHUTDOWN, MySqlParserSUPER, MySqlParserSYSTEM_VARIABLES_ADMIN, MySqlParserTABLES, MySqlParserTABLE_ENCRYPTION_ADMIN, MySqlParserVERSION_TOKEN_ADMIN, MySqlParserXA_RECOVER_ADMIN, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserARCHIVE, MySqlParserBLACKHOLE, MySqlParserCSV, MySqlParserFEDERATED, MySqlParserINNODB, MySqlParserMEMORY, MySqlParserMRG_MYISAM, MySqlParserMYISAM, MySqlParserNDB, MySqlParserNDBCLUSTER, MySqlParserPERFORMANCE_SCHEMA, MySqlParserTOKUDB, MySqlParserREPEATABLE, MySqlParserCOMMITTED, MySqlParserUNCOMMITTED, MySqlParserSERIALIZABLE, MySqlParserGEOMETRYCOLLECTION, MySqlParserLINESTRING, MySqlParserMULTILINESTRING, MySqlParserMULTIPOINT, MySqlParserMULTIPOLYGON, MySqlParserPOINT, MySqlParserPOLYGON, MySqlParserABS, MySqlParserACOS, MySqlParserADDDATE, MySqlParserADDTIME, MySqlParserAES_DECRYPT, MySqlParserAES_ENCRYPT, MySqlParserAREA, MySqlParserASBINARY, MySqlParserASIN, MySqlParserASTEXT, MySqlParserASWKB, MySqlParserASWKT, MySqlParserASYMMETRIC_DECRYPT, MySqlParserASYMMETRIC_DERIVE, MySqlParserASYMMETRIC_ENCRYPT, MySqlParserASYMMETRIC_SIGN, MySqlParserASYMMETRIC_VERIFY, MySqlParserATAN, MySqlParserATAN2, MySqlParserBENCHMARK, MySqlParserBIN, MySqlParserBIT_COUNT, MySqlParserBIT_LENGTH, MySqlParserBUFFER, MySqlParserCATALOG_NAME, MySqlParserCEIL, MySqlParserCEILING, MySqlParserCENTROID, MySqlParserCHARACTER_LENGTH, MySqlParserCHARSET, MySqlParserCHAR_LENGTH, MySqlParserCOERCIBILITY, MySqlParserCOLLATION, MySqlParserCOMPRESS, MySqlParserCONCAT, MySqlParserCONCAT_WS, MySqlParserCONNECTION_ID, MySqlParserCONV, MySqlParserCONVERT_TZ, MySqlParserCOS, MySqlParserCOT, MySqlParserCRC32, MySqlParserCREATE_ASYMMETRIC_PRIV_KEY, MySqlParserCREATE_ASYMMETRIC_PUB_KEY, MySqlParserCREATE_DH_PARAMETERS, MySqlParserCREATE_DIGEST, MySqlParserCROSSES, MySqlParserDATEDIFF, MySqlParserDATE_FORMAT, MySqlParserDAYNAME, MySqlParserDAYOFMONTH, MySqlParserDAYOFWEEK, MySqlParserDAYOFYEAR, MySqlParserDECODE, MySqlParserDEGREES, MySqlParserDES_DECRYPT, MySqlParserDES_ENCRYPT, MySqlParserDIMENSION, MySqlParserDISJOINT, MySqlParserDISTANCE, MySqlParserELT, MySqlParserENCODE, MySqlParserENCRYPT, MySqlParserENDPOINT, MySqlParserENGINE_ATTRIBUTE, MySqlParserENVELOPE, MySqlParserEQUALS, MySqlParserEXP, MySqlParserEXPORT_SET, MySqlParserEXTERIORRING, MySqlParserEXTRACTVALUE, MySqlParserFIELD, MySqlParserFIND_IN_SET, MySqlParserFLOOR, MySqlParserFORMAT, MySqlParserFOUND_ROWS, MySqlParserFROM_BASE64, MySqlParserFROM_DAYS, MySqlParserFROM_UNIXTIME, MySqlParserGEOMCOLLFROMTEXT, MySqlParserGEOMCOLLFROMWKB, MySqlParserGEOMETRYCOLLECTIONFROMTEXT, MySqlParserGEOMETRYCOLLECTIONFROMWKB, MySqlParserGEOMETRYFROMTEXT, MySqlParserGEOMETRYFROMWKB, MySqlParserGEOMETRYN, MySqlParserGEOMETRYTYPE, MySqlParserGEOMFROMTEXT, MySqlParserGEOMFROMWKB, MySqlParserGET_FORMAT, MySqlParserGET_LOCK, MySqlParserGLENGTH, MySqlParserGREATEST, MySqlParserGTID_SUBSET, MySqlParserGTID_SUBTRACT, MySqlParserHEX, MySqlParserIFNULL, MySqlParserINET6_ATON, MySqlParserINET6_NTOA, MySqlParserINET_ATON, MySqlParserINET_NTOA, MySqlParserINSTR, MySqlParserINTERIORRINGN, MySqlParserINTERSECTS, MySqlParserISCLOSED, MySqlParserISEMPTY, MySqlParserISNULL, MySqlParserISSIMPLE, MySqlParserIS_FREE_LOCK, MySqlParserIS_IPV4, MySqlParserIS_IPV4_COMPAT, MySqlParserIS_IPV4_MAPPED, MySqlParserIS_IPV6, MySqlParserIS_USED_LOCK, MySqlParserLAST_INSERT_ID, MySqlParserLCASE, MySqlParserLEAST, MySqlParserLENGTH, MySqlParserLINEFROMTEXT, MySqlParserLINEFROMWKB, MySqlParserLINESTRINGFROMTEXT, MySqlParserLINESTRINGFROMWKB, MySqlParserLN, MySqlParserLOAD_FILE, MySqlParserLOCATE, MySqlParserLOG, MySqlParserLOG10, MySqlParserLOG2, MySqlParserLOWER, MySqlParserLPAD, MySqlParserLTRIM, MySqlParserMAKEDATE, MySqlParserMAKETIME, MySqlParserMAKE_SET, MySqlParserMASTER_POS_WAIT, MySqlParserMBRCONTAINS, MySqlParserMBRDISJOINT, MySqlParserMBREQUAL, MySqlParserMBRINTERSECTS, MySqlParserMBROVERLAPS, MySqlParserMBRTOUCHES, MySqlParserMBRWITHIN, MySqlParserMD5, MySqlParserMLINEFROMTEXT, MySqlParserMLINEFROMWKB, MySqlParserMONTHNAME, MySqlParserMPOINTFROMTEXT, MySqlParserMPOINTFROMWKB, MySqlParserMPOLYFROMTEXT, MySqlParserMPOLYFROMWKB, MySqlParserMULTILINESTRINGFROMTEXT, MySqlParserMULTILINESTRINGFROMWKB, MySqlParserMULTIPOINTFROMTEXT, MySqlParserMULTIPOINTFROMWKB, MySqlParserMULTIPOLYGONFROMTEXT, MySqlParserMULTIPOLYGONFROMWKB, MySqlParserNAME_CONST, MySqlParserNULLIF, MySqlParserNUMGEOMETRIES, MySqlParserNUMINTERIORRINGS, MySqlParserNUMPOINTS, MySqlParserOCT, MySqlParserOCTET_LENGTH, MySqlParserORD, MySqlParserOVERLAPS, MySqlParserPERIOD_ADD, MySqlParserPERIOD_DIFF, MySqlParserPI, MySqlParserPOINTFROMTEXT, MySqlParserPOINTFROMWKB, MySqlParserPOINTN, MySqlParserPOLYFROMTEXT, MySqlParserPOLYFROMWKB, MySqlParserPOLYGONFROMTEXT, MySqlParserPOLYGONFROMWKB, MySqlParserPOW, MySqlParserPOWER, MySqlParserQUOTE, MySqlParserRADIANS, MySqlParserRAND, MySqlParserRANDOM, MySqlParserRANDOM_BYTES, MySqlParserRELEASE_LOCK, MySqlParserREVERSE, MySqlParserROUND, MySqlParserROW_COUNT, MySqlParserRPAD, MySqlParserRTRIM, MySqlParserSEC_TO_TIME, MySqlParserSECONDARY_ENGINE_ATTRIBUTE, MySqlParserSESSION_USER, MySqlParserSHA, MySqlParserSHA1, MySqlParserSHA2, MySqlParserSCHEMA_NAME, MySqlParserSIGN, MySqlParserSIN, MySqlParserSLEEP, MySqlParserSOUNDEX, MySqlParserSQL_THREAD_WAIT_AFTER_GTIDS, MySqlParserSQRT, MySqlParserSRID, MySqlParserSTARTPOINT, MySqlParserSTRCMP, MySqlParserSTR_TO_DATE, MySqlParserST_AREA, MySqlParserST_ASBINARY, MySqlParserST_ASTEXT, MySqlParserST_ASWKB, MySqlParserST_ASWKT, MySqlParserST_BUFFER, MySqlParserST_CENTROID, MySqlParserST_CONTAINS, MySqlParserST_CROSSES, MySqlParserST_DIFFERENCE, MySqlParserST_DIMENSION, MySqlParserST_DISJOINT, MySqlParserST_DISTANCE, MySqlParserST_ENDPOINT, MySqlParserST_ENVELOPE, MySqlParserST_EQUALS, MySqlParserST_EXTERIORRING, MySqlParserST_GEOMCOLLFROMTEXT, MySqlParserST_GEOMCOLLFROMTXT, MySqlParserST_GEOMCOLLFROMWKB, MySqlParserST_GEOMETRYCOLLECTIONFROMTEXT, MySqlParserST_GEOMETRYCOLLECTIONFROMWKB, MySqlParserST_GEOMETRYFROMTEXT, MySqlParserST_GEOMETRYFROMWKB, MySqlParserST_GEOMETRYN, MySqlParserST_GEOMETRYTYPE, MySqlParserST_GEOMFROMTEXT, MySqlParserST_GEOMFROMWKB, MySqlParserST_INTERIORRINGN, MySqlParserST_INTERSECTION, MySqlParserST_INTERSECTS, MySqlParserST_ISCLOSED, MySqlParserST_ISEMPTY, MySqlParserST_ISSIMPLE, MySqlParserST_LINEFROMTEXT, MySqlParserST_LINEFROMWKB, MySqlParserST_LINESTRINGFROMTEXT, MySqlParserST_LINESTRINGFROMWKB, MySqlParserST_NUMGEOMETRIES, MySqlParserST_NUMINTERIORRING, MySqlParserST_NUMINTERIORRINGS, MySqlParserST_NUMPOINTS, MySqlParserST_OVERLAPS, MySqlParserST_POINTFROMTEXT, MySqlParserST_POINTFROMWKB, MySqlParserST_POINTN, MySqlParserST_POLYFROMTEXT, MySqlParserST_POLYFROMWKB, MySqlParserST_POLYGONFROMTEXT, MySqlParserST_POLYGONFROMWKB, MySqlParserST_SRID, MySqlParserST_STARTPOINT, MySqlParserST_SYMDIFFERENCE, MySqlParserST_TOUCHES, MySqlParserST_UNION, MySqlParserST_WITHIN, MySqlParserST_X, MySqlParserST_Y, MySqlParserSTRING_TO_VECTOR, MySqlParserSUBDATE, MySqlParserSUBSTRING_INDEX, MySqlParserSUBTIME, MySqlParserSYSTEM_USER, MySqlParserTAN, MySqlParserTIMEDIFF, MySqlParserTIMESTAMPADD, MySqlParserTIMESTAMPDIFF, MySqlParserTIME_FORMAT, MySqlParserTIME_TO_SEC, MySqlParserTOUCHES, MySqlParserTO_BASE64, MySqlParserTO_DAYS, MySqlParserTO_SECONDS, MySqlParserTP_CONNECTION_ADMIN, MySqlParserUCASE, MySqlParserUNCOMPRESS, MySqlParserUNCOMPRESSED_LENGTH, MySqlParserUNHEX, MySqlParserUNIX_TIMESTAMP, MySqlParserUPDATEXML, MySqlParserUPPER, MySqlParserUUID, MySqlParserUUID_SHORT, MySqlParserVALIDATE_PASSWORD_STRENGTH, MySqlParserVECTOR_DIM, MySqlParserVECTOR_TO_STRING, MySqlParserVERSION, MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS, MySqlParserWEEKDAY, MySqlParserWEEKOFYEAR, MySqlParserWEIGHT_STRING, MySqlParserWITHIN, MySqlParserYEARWEEK, MySqlParserY_FUNCTION, MySqlParserX_FUNCTION, MySqlParserMOD, MySqlParserCHARSET_REVERSE_QOUTE_STRING, MySqlParserSTRING_LITERAL, MySqlParserID: + { + p.SetState(2975) + p.UidList() + } + + case MySqlParserALL: + { + p.SetState(2976) + p.Match(MySqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case MySqlParserREMOVE: + localctx = NewAlterByRemovePartitioningContext(p, localctx) + p.EnterOuterAlt(localctx, 14) + { + p.SetState(2979) + p.Match(MySqlParserREMOVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2980) + p.Match(MySqlParserPARTITIONING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserUPGRADE: + localctx = NewAlterByUpgradePartitioningContext(p, localctx) + p.EnterOuterAlt(localctx, 15) + { + p.SetState(2981) + p.Match(MySqlParserUPGRADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2982) + p.Match(MySqlParserPARTITIONING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDropDatabaseContext is an interface to support dynamic dispatch. +type IDropDatabaseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetDbFormat returns the dbFormat token. + GetDbFormat() antlr.Token + + // SetDbFormat sets the dbFormat token. + SetDbFormat(antlr.Token) + + // Getter signatures + DROP() antlr.TerminalNode + Uid() IUidContext + DATABASE() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + IfExists() IIfExistsContext + + // IsDropDatabaseContext differentiates from other interfaces. + IsDropDatabaseContext() +} + +type DropDatabaseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + dbFormat antlr.Token +} + +func NewEmptyDropDatabaseContext() *DropDatabaseContext { + var p = new(DropDatabaseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_dropDatabase + return p +} + +func InitEmptyDropDatabaseContext(p *DropDatabaseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_dropDatabase +} + +func (*DropDatabaseContext) IsDropDatabaseContext() {} + +func NewDropDatabaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropDatabaseContext { + var p = new(DropDatabaseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_dropDatabase + + return p +} + +func (s *DropDatabaseContext) GetParser() antlr.Parser { return s.parser } + +func (s *DropDatabaseContext) GetDbFormat() antlr.Token { return s.dbFormat } + +func (s *DropDatabaseContext) SetDbFormat(v antlr.Token) { s.dbFormat = v } + +func (s *DropDatabaseContext) DROP() antlr.TerminalNode { + return s.GetToken(MySqlParserDROP, 0) +} + +func (s *DropDatabaseContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *DropDatabaseContext) DATABASE() antlr.TerminalNode { + return s.GetToken(MySqlParserDATABASE, 0) +} + +func (s *DropDatabaseContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(MySqlParserSCHEMA, 0) +} + +func (s *DropDatabaseContext) IfExists() IIfExistsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfExistsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfExistsContext) +} + +func (s *DropDatabaseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropDatabaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DropDatabaseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterDropDatabase(s) + } +} + +func (s *DropDatabaseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitDropDatabase(s) + } +} + +func (p *MySqlParser) DropDatabase() (localctx IDropDatabaseContext) { + localctx = NewDropDatabaseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 152, MySqlParserRULE_dropDatabase) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2985) + p.Match(MySqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2986) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*DropDatabaseContext).dbFormat = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserDATABASE || _la == MySqlParserSCHEMA) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*DropDatabaseContext).dbFormat = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(2988) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 383, p.GetParserRuleContext()) == 1 { + { + p.SetState(2987) + p.IfExists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(2990) + p.Uid() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDropEventContext is an interface to support dynamic dispatch. +type IDropEventContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + EVENT() antlr.TerminalNode + FullId() IFullIdContext + IfExists() IIfExistsContext + + // IsDropEventContext differentiates from other interfaces. + IsDropEventContext() +} + +type DropEventContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDropEventContext() *DropEventContext { + var p = new(DropEventContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_dropEvent + return p +} + +func InitEmptyDropEventContext(p *DropEventContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_dropEvent +} + +func (*DropEventContext) IsDropEventContext() {} + +func NewDropEventContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropEventContext { + var p = new(DropEventContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_dropEvent + + return p +} + +func (s *DropEventContext) GetParser() antlr.Parser { return s.parser } + +func (s *DropEventContext) DROP() antlr.TerminalNode { + return s.GetToken(MySqlParserDROP, 0) +} + +func (s *DropEventContext) EVENT() antlr.TerminalNode { + return s.GetToken(MySqlParserEVENT, 0) +} + +func (s *DropEventContext) FullId() IFullIdContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFullIdContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFullIdContext) +} + +func (s *DropEventContext) IfExists() IIfExistsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfExistsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfExistsContext) +} + +func (s *DropEventContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropEventContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DropEventContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterDropEvent(s) + } +} + +func (s *DropEventContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitDropEvent(s) + } +} + +func (p *MySqlParser) DropEvent() (localctx IDropEventContext) { + localctx = NewDropEventContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 154, MySqlParserRULE_dropEvent) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2992) + p.Match(MySqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2993) + p.Match(MySqlParserEVENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2995) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 384, p.GetParserRuleContext()) == 1 { + { + p.SetState(2994) + p.IfExists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(2997) + p.FullId() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDropIndexContext is an interface to support dynamic dispatch. +type IDropIndexContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetIntimeAction returns the intimeAction token. + GetIntimeAction() antlr.Token + + // GetAlgType returns the algType token. + GetAlgType() antlr.Token + + // GetLockType returns the lockType token. + GetLockType() antlr.Token + + // SetIntimeAction sets the intimeAction token. + SetIntimeAction(antlr.Token) + + // SetAlgType sets the algType token. + SetAlgType(antlr.Token) + + // SetLockType sets the lockType token. + SetLockType(antlr.Token) + + // Getter signatures + DROP() antlr.TerminalNode + INDEX() antlr.TerminalNode + Uid() IUidContext + ON() antlr.TerminalNode + TableName() ITableNameContext + AllALGORITHM() []antlr.TerminalNode + ALGORITHM(i int) antlr.TerminalNode + AllLOCK() []antlr.TerminalNode + LOCK(i int) antlr.TerminalNode + ONLINE() antlr.TerminalNode + OFFLINE() antlr.TerminalNode + AllDEFAULT() []antlr.TerminalNode + DEFAULT(i int) antlr.TerminalNode + AllINPLACE() []antlr.TerminalNode + INPLACE(i int) antlr.TerminalNode + AllCOPY() []antlr.TerminalNode + COPY(i int) antlr.TerminalNode + AllNONE() []antlr.TerminalNode + NONE(i int) antlr.TerminalNode + AllSHARED() []antlr.TerminalNode + SHARED(i int) antlr.TerminalNode + AllEXCLUSIVE() []antlr.TerminalNode + EXCLUSIVE(i int) antlr.TerminalNode + AllEQUAL_SYMBOL() []antlr.TerminalNode + EQUAL_SYMBOL(i int) antlr.TerminalNode + + // IsDropIndexContext differentiates from other interfaces. + IsDropIndexContext() +} + +type DropIndexContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + intimeAction antlr.Token + algType antlr.Token + lockType antlr.Token +} + +func NewEmptyDropIndexContext() *DropIndexContext { + var p = new(DropIndexContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_dropIndex + return p +} + +func InitEmptyDropIndexContext(p *DropIndexContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_dropIndex +} + +func (*DropIndexContext) IsDropIndexContext() {} + +func NewDropIndexContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropIndexContext { + var p = new(DropIndexContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_dropIndex + + return p +} + +func (s *DropIndexContext) GetParser() antlr.Parser { return s.parser } + +func (s *DropIndexContext) GetIntimeAction() antlr.Token { return s.intimeAction } + +func (s *DropIndexContext) GetAlgType() antlr.Token { return s.algType } + +func (s *DropIndexContext) GetLockType() antlr.Token { return s.lockType } + +func (s *DropIndexContext) SetIntimeAction(v antlr.Token) { s.intimeAction = v } + +func (s *DropIndexContext) SetAlgType(v antlr.Token) { s.algType = v } + +func (s *DropIndexContext) SetLockType(v antlr.Token) { s.lockType = v } + +func (s *DropIndexContext) DROP() antlr.TerminalNode { + return s.GetToken(MySqlParserDROP, 0) +} + +func (s *DropIndexContext) INDEX() antlr.TerminalNode { + return s.GetToken(MySqlParserINDEX, 0) +} + +func (s *DropIndexContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *DropIndexContext) ON() antlr.TerminalNode { + return s.GetToken(MySqlParserON, 0) +} + +func (s *DropIndexContext) TableName() ITableNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableNameContext) +} + +func (s *DropIndexContext) AllALGORITHM() []antlr.TerminalNode { + return s.GetTokens(MySqlParserALGORITHM) +} + +func (s *DropIndexContext) ALGORITHM(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserALGORITHM, i) +} + +func (s *DropIndexContext) AllLOCK() []antlr.TerminalNode { + return s.GetTokens(MySqlParserLOCK) +} + +func (s *DropIndexContext) LOCK(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserLOCK, i) +} + +func (s *DropIndexContext) ONLINE() antlr.TerminalNode { + return s.GetToken(MySqlParserONLINE, 0) +} + +func (s *DropIndexContext) OFFLINE() antlr.TerminalNode { + return s.GetToken(MySqlParserOFFLINE, 0) +} + +func (s *DropIndexContext) AllDEFAULT() []antlr.TerminalNode { + return s.GetTokens(MySqlParserDEFAULT) +} + +func (s *DropIndexContext) DEFAULT(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserDEFAULT, i) +} + +func (s *DropIndexContext) AllINPLACE() []antlr.TerminalNode { + return s.GetTokens(MySqlParserINPLACE) +} + +func (s *DropIndexContext) INPLACE(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserINPLACE, i) +} + +func (s *DropIndexContext) AllCOPY() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOPY) +} + +func (s *DropIndexContext) COPY(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOPY, i) +} + +func (s *DropIndexContext) AllNONE() []antlr.TerminalNode { + return s.GetTokens(MySqlParserNONE) +} + +func (s *DropIndexContext) NONE(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserNONE, i) +} + +func (s *DropIndexContext) AllSHARED() []antlr.TerminalNode { + return s.GetTokens(MySqlParserSHARED) +} + +func (s *DropIndexContext) SHARED(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserSHARED, i) +} + +func (s *DropIndexContext) AllEXCLUSIVE() []antlr.TerminalNode { + return s.GetTokens(MySqlParserEXCLUSIVE) +} + +func (s *DropIndexContext) EXCLUSIVE(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserEXCLUSIVE, i) +} + +func (s *DropIndexContext) AllEQUAL_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(MySqlParserEQUAL_SYMBOL) +} + +func (s *DropIndexContext) EQUAL_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, i) +} + +func (s *DropIndexContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropIndexContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DropIndexContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterDropIndex(s) + } +} + +func (s *DropIndexContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitDropIndex(s) + } +} + +func (p *MySqlParser) DropIndex() (localctx IDropIndexContext) { + localctx = NewDropIndexContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 156, MySqlParserRULE_dropIndex) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2999) + p.Match(MySqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3000) + p.Match(MySqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3002) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 385, p.GetParserRuleContext()) == 1 { + { + p.SetState(3001) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*DropIndexContext).intimeAction = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserOFFLINE || _la == MySqlParserONLINE) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*DropIndexContext).intimeAction = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3004) + p.Uid() + } + { + p.SetState(3005) + p.Match(MySqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3006) + p.TableName() + } + p.SetState(3019) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 389, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(3017) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserALGORITHM: + { + p.SetState(3007) + p.Match(MySqlParserALGORITHM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3009) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(3008) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3011) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*DropIndexContext).algType = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserDEFAULT || _la == MySqlParserCOPY || _la == MySqlParserINPLACE) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*DropIndexContext).algType = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case MySqlParserLOCK: + { + p.SetState(3012) + p.Match(MySqlParserLOCK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3014) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(3013) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3016) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*DropIndexContext).lockType = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserDEFAULT || _la == MySqlParserEXCLUSIVE || _la == MySqlParserNONE || _la == MySqlParserSHARED) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*DropIndexContext).lockType = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(3021) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 389, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDropLogfileGroupContext is an interface to support dynamic dispatch. +type IDropLogfileGroupContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + LOGFILE() antlr.TerminalNode + GROUP() antlr.TerminalNode + Uid() IUidContext + ENGINE() antlr.TerminalNode + EQUAL_SYMBOL() antlr.TerminalNode + EngineName() IEngineNameContext + + // IsDropLogfileGroupContext differentiates from other interfaces. + IsDropLogfileGroupContext() +} + +type DropLogfileGroupContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDropLogfileGroupContext() *DropLogfileGroupContext { + var p = new(DropLogfileGroupContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_dropLogfileGroup + return p +} + +func InitEmptyDropLogfileGroupContext(p *DropLogfileGroupContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_dropLogfileGroup +} + +func (*DropLogfileGroupContext) IsDropLogfileGroupContext() {} + +func NewDropLogfileGroupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropLogfileGroupContext { + var p = new(DropLogfileGroupContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_dropLogfileGroup + + return p +} + +func (s *DropLogfileGroupContext) GetParser() antlr.Parser { return s.parser } + +func (s *DropLogfileGroupContext) DROP() antlr.TerminalNode { + return s.GetToken(MySqlParserDROP, 0) +} + +func (s *DropLogfileGroupContext) LOGFILE() antlr.TerminalNode { + return s.GetToken(MySqlParserLOGFILE, 0) +} + +func (s *DropLogfileGroupContext) GROUP() antlr.TerminalNode { + return s.GetToken(MySqlParserGROUP, 0) +} + +func (s *DropLogfileGroupContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *DropLogfileGroupContext) ENGINE() antlr.TerminalNode { + return s.GetToken(MySqlParserENGINE, 0) +} + +func (s *DropLogfileGroupContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *DropLogfileGroupContext) EngineName() IEngineNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEngineNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEngineNameContext) +} + +func (s *DropLogfileGroupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropLogfileGroupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DropLogfileGroupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterDropLogfileGroup(s) + } +} + +func (s *DropLogfileGroupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitDropLogfileGroup(s) + } +} + +func (p *MySqlParser) DropLogfileGroup() (localctx IDropLogfileGroupContext) { + localctx = NewDropLogfileGroupContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 158, MySqlParserRULE_dropLogfileGroup) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3022) + p.Match(MySqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3023) + p.Match(MySqlParserLOGFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3024) + p.Match(MySqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3025) + p.Uid() + } + { + p.SetState(3026) + p.Match(MySqlParserENGINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3027) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3028) + p.EngineName() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDropProcedureContext is an interface to support dynamic dispatch. +type IDropProcedureContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + PROCEDURE() antlr.TerminalNode + FullId() IFullIdContext + IfExists() IIfExistsContext + + // IsDropProcedureContext differentiates from other interfaces. + IsDropProcedureContext() +} + +type DropProcedureContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDropProcedureContext() *DropProcedureContext { + var p = new(DropProcedureContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_dropProcedure + return p +} + +func InitEmptyDropProcedureContext(p *DropProcedureContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_dropProcedure +} + +func (*DropProcedureContext) IsDropProcedureContext() {} + +func NewDropProcedureContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropProcedureContext { + var p = new(DropProcedureContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_dropProcedure + + return p +} + +func (s *DropProcedureContext) GetParser() antlr.Parser { return s.parser } + +func (s *DropProcedureContext) DROP() antlr.TerminalNode { + return s.GetToken(MySqlParserDROP, 0) +} + +func (s *DropProcedureContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(MySqlParserPROCEDURE, 0) +} + +func (s *DropProcedureContext) FullId() IFullIdContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFullIdContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFullIdContext) +} + +func (s *DropProcedureContext) IfExists() IIfExistsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfExistsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfExistsContext) +} + +func (s *DropProcedureContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropProcedureContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DropProcedureContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterDropProcedure(s) + } +} + +func (s *DropProcedureContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitDropProcedure(s) + } +} + +func (p *MySqlParser) DropProcedure() (localctx IDropProcedureContext) { + localctx = NewDropProcedureContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 160, MySqlParserRULE_dropProcedure) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3030) + p.Match(MySqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3031) + p.Match(MySqlParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3033) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 390, p.GetParserRuleContext()) == 1 { + { + p.SetState(3032) + p.IfExists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3035) + p.FullId() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDropFunctionContext is an interface to support dynamic dispatch. +type IDropFunctionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + FullId() IFullIdContext + IfExists() IIfExistsContext + + // IsDropFunctionContext differentiates from other interfaces. + IsDropFunctionContext() +} + +type DropFunctionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDropFunctionContext() *DropFunctionContext { + var p = new(DropFunctionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_dropFunction + return p +} + +func InitEmptyDropFunctionContext(p *DropFunctionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_dropFunction +} + +func (*DropFunctionContext) IsDropFunctionContext() {} + +func NewDropFunctionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropFunctionContext { + var p = new(DropFunctionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_dropFunction + + return p +} + +func (s *DropFunctionContext) GetParser() antlr.Parser { return s.parser } + +func (s *DropFunctionContext) DROP() antlr.TerminalNode { + return s.GetToken(MySqlParserDROP, 0) +} + +func (s *DropFunctionContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(MySqlParserFUNCTION, 0) +} + +func (s *DropFunctionContext) FullId() IFullIdContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFullIdContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFullIdContext) +} + +func (s *DropFunctionContext) IfExists() IIfExistsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfExistsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfExistsContext) +} + +func (s *DropFunctionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropFunctionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DropFunctionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterDropFunction(s) + } +} + +func (s *DropFunctionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitDropFunction(s) + } +} + +func (p *MySqlParser) DropFunction() (localctx IDropFunctionContext) { + localctx = NewDropFunctionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 162, MySqlParserRULE_dropFunction) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3037) + p.Match(MySqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3038) + p.Match(MySqlParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3040) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 391, p.GetParserRuleContext()) == 1 { + { + p.SetState(3039) + p.IfExists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3042) + p.FullId() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDropServerContext is an interface to support dynamic dispatch. +type IDropServerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + SERVER() antlr.TerminalNode + Uid() IUidContext + IfExists() IIfExistsContext + + // IsDropServerContext differentiates from other interfaces. + IsDropServerContext() +} + +type DropServerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDropServerContext() *DropServerContext { + var p = new(DropServerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_dropServer + return p +} + +func InitEmptyDropServerContext(p *DropServerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_dropServer +} + +func (*DropServerContext) IsDropServerContext() {} + +func NewDropServerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropServerContext { + var p = new(DropServerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_dropServer + + return p +} + +func (s *DropServerContext) GetParser() antlr.Parser { return s.parser } + +func (s *DropServerContext) DROP() antlr.TerminalNode { + return s.GetToken(MySqlParserDROP, 0) +} + +func (s *DropServerContext) SERVER() antlr.TerminalNode { + return s.GetToken(MySqlParserSERVER, 0) +} + +func (s *DropServerContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *DropServerContext) IfExists() IIfExistsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfExistsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfExistsContext) +} + +func (s *DropServerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropServerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DropServerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterDropServer(s) + } +} + +func (s *DropServerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitDropServer(s) + } +} + +func (p *MySqlParser) DropServer() (localctx IDropServerContext) { + localctx = NewDropServerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 164, MySqlParserRULE_dropServer) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3044) + p.Match(MySqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3045) + p.Match(MySqlParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3047) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 392, p.GetParserRuleContext()) == 1 { + { + p.SetState(3046) + p.IfExists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3049) + p.Uid() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDropTableContext is an interface to support dynamic dispatch. +type IDropTableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetDropType returns the dropType token. + GetDropType() antlr.Token + + // SetDropType sets the dropType token. + SetDropType(antlr.Token) + + // Getter signatures + DROP() antlr.TerminalNode + TABLE() antlr.TerminalNode + Tables() ITablesContext + TEMPORARY() antlr.TerminalNode + IfExists() IIfExistsContext + RESTRICT() antlr.TerminalNode + CASCADE() antlr.TerminalNode + + // IsDropTableContext differentiates from other interfaces. + IsDropTableContext() +} + +type DropTableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + dropType antlr.Token +} + +func NewEmptyDropTableContext() *DropTableContext { + var p = new(DropTableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_dropTable + return p +} + +func InitEmptyDropTableContext(p *DropTableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_dropTable +} + +func (*DropTableContext) IsDropTableContext() {} + +func NewDropTableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropTableContext { + var p = new(DropTableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_dropTable + + return p +} + +func (s *DropTableContext) GetParser() antlr.Parser { return s.parser } + +func (s *DropTableContext) GetDropType() antlr.Token { return s.dropType } + +func (s *DropTableContext) SetDropType(v antlr.Token) { s.dropType = v } + +func (s *DropTableContext) DROP() antlr.TerminalNode { + return s.GetToken(MySqlParserDROP, 0) +} + +func (s *DropTableContext) TABLE() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLE, 0) +} + +func (s *DropTableContext) Tables() ITablesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablesContext) +} + +func (s *DropTableContext) TEMPORARY() antlr.TerminalNode { + return s.GetToken(MySqlParserTEMPORARY, 0) +} + +func (s *DropTableContext) IfExists() IIfExistsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfExistsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfExistsContext) +} + +func (s *DropTableContext) RESTRICT() antlr.TerminalNode { + return s.GetToken(MySqlParserRESTRICT, 0) +} + +func (s *DropTableContext) CASCADE() antlr.TerminalNode { + return s.GetToken(MySqlParserCASCADE, 0) +} + +func (s *DropTableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropTableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DropTableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterDropTable(s) + } +} + +func (s *DropTableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitDropTable(s) + } +} + +func (p *MySqlParser) DropTable() (localctx IDropTableContext) { + localctx = NewDropTableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 166, MySqlParserRULE_dropTable) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3051) + p.Match(MySqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3053) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserTEMPORARY { + { + p.SetState(3052) + p.Match(MySqlParserTEMPORARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3055) + p.Match(MySqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3057) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 394, p.GetParserRuleContext()) == 1 { + { + p.SetState(3056) + p.IfExists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3059) + p.Tables() + } + p.SetState(3061) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserCASCADE || _la == MySqlParserRESTRICT { + { + p.SetState(3060) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*DropTableContext).dropType = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserCASCADE || _la == MySqlParserRESTRICT) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*DropTableContext).dropType = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDropTablespaceContext is an interface to support dynamic dispatch. +type IDropTablespaceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + Uid() IUidContext + ENGINE() antlr.TerminalNode + EngineName() IEngineNameContext + EQUAL_SYMBOL() antlr.TerminalNode + + // IsDropTablespaceContext differentiates from other interfaces. + IsDropTablespaceContext() +} + +type DropTablespaceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDropTablespaceContext() *DropTablespaceContext { + var p = new(DropTablespaceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_dropTablespace + return p +} + +func InitEmptyDropTablespaceContext(p *DropTablespaceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_dropTablespace +} + +func (*DropTablespaceContext) IsDropTablespaceContext() {} + +func NewDropTablespaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropTablespaceContext { + var p = new(DropTablespaceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_dropTablespace + + return p +} + +func (s *DropTablespaceContext) GetParser() antlr.Parser { return s.parser } + +func (s *DropTablespaceContext) DROP() antlr.TerminalNode { + return s.GetToken(MySqlParserDROP, 0) +} + +func (s *DropTablespaceContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLESPACE, 0) +} + +func (s *DropTablespaceContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *DropTablespaceContext) ENGINE() antlr.TerminalNode { + return s.GetToken(MySqlParserENGINE, 0) +} + +func (s *DropTablespaceContext) EngineName() IEngineNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEngineNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEngineNameContext) +} + +func (s *DropTablespaceContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *DropTablespaceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropTablespaceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DropTablespaceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterDropTablespace(s) + } +} + +func (s *DropTablespaceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitDropTablespace(s) + } +} + +func (p *MySqlParser) DropTablespace() (localctx IDropTablespaceContext) { + localctx = NewDropTablespaceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 168, MySqlParserRULE_dropTablespace) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3063) + p.Match(MySqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3064) + p.Match(MySqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3065) + p.Uid() + } + p.SetState(3071) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserENGINE { + { + p.SetState(3066) + p.Match(MySqlParserENGINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3068) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEQUAL_SYMBOL { + { + p.SetState(3067) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3070) + p.EngineName() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDropTriggerContext is an interface to support dynamic dispatch. +type IDropTriggerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + TRIGGER() antlr.TerminalNode + FullId() IFullIdContext + IfExists() IIfExistsContext + + // IsDropTriggerContext differentiates from other interfaces. + IsDropTriggerContext() +} + +type DropTriggerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDropTriggerContext() *DropTriggerContext { + var p = new(DropTriggerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_dropTrigger + return p +} + +func InitEmptyDropTriggerContext(p *DropTriggerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_dropTrigger +} + +func (*DropTriggerContext) IsDropTriggerContext() {} + +func NewDropTriggerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropTriggerContext { + var p = new(DropTriggerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_dropTrigger + + return p +} + +func (s *DropTriggerContext) GetParser() antlr.Parser { return s.parser } + +func (s *DropTriggerContext) DROP() antlr.TerminalNode { + return s.GetToken(MySqlParserDROP, 0) +} + +func (s *DropTriggerContext) TRIGGER() antlr.TerminalNode { + return s.GetToken(MySqlParserTRIGGER, 0) +} + +func (s *DropTriggerContext) FullId() IFullIdContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFullIdContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFullIdContext) +} + +func (s *DropTriggerContext) IfExists() IIfExistsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfExistsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfExistsContext) +} + +func (s *DropTriggerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropTriggerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DropTriggerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterDropTrigger(s) + } +} + +func (s *DropTriggerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitDropTrigger(s) + } +} + +func (p *MySqlParser) DropTrigger() (localctx IDropTriggerContext) { + localctx = NewDropTriggerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 170, MySqlParserRULE_dropTrigger) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3073) + p.Match(MySqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3074) + p.Match(MySqlParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3076) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 398, p.GetParserRuleContext()) == 1 { + { + p.SetState(3075) + p.IfExists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3078) + p.FullId() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDropViewContext is an interface to support dynamic dispatch. +type IDropViewContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetDropType returns the dropType token. + GetDropType() antlr.Token + + // SetDropType sets the dropType token. + SetDropType(antlr.Token) + + // Getter signatures + DROP() antlr.TerminalNode + VIEW() antlr.TerminalNode + AllFullId() []IFullIdContext + FullId(i int) IFullIdContext + IfExists() IIfExistsContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + RESTRICT() antlr.TerminalNode + CASCADE() antlr.TerminalNode + + // IsDropViewContext differentiates from other interfaces. + IsDropViewContext() +} + +type DropViewContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + dropType antlr.Token +} + +func NewEmptyDropViewContext() *DropViewContext { + var p = new(DropViewContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_dropView + return p +} + +func InitEmptyDropViewContext(p *DropViewContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_dropView +} + +func (*DropViewContext) IsDropViewContext() {} + +func NewDropViewContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropViewContext { + var p = new(DropViewContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_dropView + + return p +} + +func (s *DropViewContext) GetParser() antlr.Parser { return s.parser } + +func (s *DropViewContext) GetDropType() antlr.Token { return s.dropType } + +func (s *DropViewContext) SetDropType(v antlr.Token) { s.dropType = v } + +func (s *DropViewContext) DROP() antlr.TerminalNode { + return s.GetToken(MySqlParserDROP, 0) +} + +func (s *DropViewContext) VIEW() antlr.TerminalNode { + return s.GetToken(MySqlParserVIEW, 0) +} + +func (s *DropViewContext) AllFullId() []IFullIdContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFullIdContext); ok { + len++ + } + } + + tst := make([]IFullIdContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFullIdContext); ok { + tst[i] = t.(IFullIdContext) + i++ + } + } + + return tst +} + +func (s *DropViewContext) FullId(i int) IFullIdContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFullIdContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFullIdContext) +} + +func (s *DropViewContext) IfExists() IIfExistsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfExistsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfExistsContext) +} + +func (s *DropViewContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *DropViewContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *DropViewContext) RESTRICT() antlr.TerminalNode { + return s.GetToken(MySqlParserRESTRICT, 0) +} + +func (s *DropViewContext) CASCADE() antlr.TerminalNode { + return s.GetToken(MySqlParserCASCADE, 0) +} + +func (s *DropViewContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropViewContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DropViewContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterDropView(s) + } +} + +func (s *DropViewContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitDropView(s) + } +} + +func (p *MySqlParser) DropView() (localctx IDropViewContext) { + localctx = NewDropViewContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 172, MySqlParserRULE_dropView) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3080) + p.Match(MySqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3081) + p.Match(MySqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3083) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 399, p.GetParserRuleContext()) == 1 { + { + p.SetState(3082) + p.IfExists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3085) + p.FullId() + } + p.SetState(3090) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(3086) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3087) + p.FullId() + } + + p.SetState(3092) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(3094) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserCASCADE || _la == MySqlParserRESTRICT { + { + p.SetState(3093) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*DropViewContext).dropType = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserCASCADE || _la == MySqlParserRESTRICT) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*DropViewContext).dropType = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDropRoleContext is an interface to support dynamic dispatch. +type IDropRoleContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + ROLE() antlr.TerminalNode + AllRoleName() []IRoleNameContext + RoleName(i int) IRoleNameContext + IfExists() IIfExistsContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsDropRoleContext differentiates from other interfaces. + IsDropRoleContext() +} + +type DropRoleContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDropRoleContext() *DropRoleContext { + var p = new(DropRoleContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_dropRole + return p +} + +func InitEmptyDropRoleContext(p *DropRoleContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_dropRole +} + +func (*DropRoleContext) IsDropRoleContext() {} + +func NewDropRoleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropRoleContext { + var p = new(DropRoleContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_dropRole + + return p +} + +func (s *DropRoleContext) GetParser() antlr.Parser { return s.parser } + +func (s *DropRoleContext) DROP() antlr.TerminalNode { + return s.GetToken(MySqlParserDROP, 0) +} + +func (s *DropRoleContext) ROLE() antlr.TerminalNode { + return s.GetToken(MySqlParserROLE, 0) +} + +func (s *DropRoleContext) AllRoleName() []IRoleNameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRoleNameContext); ok { + len++ + } + } + + tst := make([]IRoleNameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRoleNameContext); ok { + tst[i] = t.(IRoleNameContext) + i++ + } + } + + return tst +} + +func (s *DropRoleContext) RoleName(i int) IRoleNameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRoleNameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRoleNameContext) +} + +func (s *DropRoleContext) IfExists() IIfExistsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfExistsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfExistsContext) +} + +func (s *DropRoleContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *DropRoleContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *DropRoleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropRoleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DropRoleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterDropRole(s) + } +} + +func (s *DropRoleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitDropRole(s) + } +} + +func (p *MySqlParser) DropRole() (localctx IDropRoleContext) { + localctx = NewDropRoleContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 174, MySqlParserRULE_dropRole) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3096) + p.Match(MySqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3097) + p.Match(MySqlParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3099) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 402, p.GetParserRuleContext()) == 1 { + { + p.SetState(3098) + p.IfExists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3101) + p.RoleName() + } + p.SetState(3106) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(3102) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3103) + p.RoleName() + } + + p.SetState(3108) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISetRoleContext is an interface to support dynamic dispatch. +type ISetRoleContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + ROLE() antlr.TerminalNode + TO() antlr.TerminalNode + NONE() antlr.TerminalNode + ALL() antlr.TerminalNode + AllRoleName() []IRoleNameContext + RoleName(i int) IRoleNameContext + AllUserName() []IUserNameContext + UserName(i int) IUserNameContext + AllUid() []IUidContext + Uid(i int) IUidContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + RoleOption() IRoleOptionContext + + // IsSetRoleContext differentiates from other interfaces. + IsSetRoleContext() +} + +type SetRoleContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySetRoleContext() *SetRoleContext { + var p = new(SetRoleContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_setRole + return p +} + +func InitEmptySetRoleContext(p *SetRoleContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_setRole +} + +func (*SetRoleContext) IsSetRoleContext() {} + +func NewSetRoleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SetRoleContext { + var p = new(SetRoleContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_setRole + + return p +} + +func (s *SetRoleContext) GetParser() antlr.Parser { return s.parser } + +func (s *SetRoleContext) SET() antlr.TerminalNode { + return s.GetToken(MySqlParserSET, 0) +} + +func (s *SetRoleContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(MySqlParserDEFAULT, 0) +} + +func (s *SetRoleContext) ROLE() antlr.TerminalNode { + return s.GetToken(MySqlParserROLE, 0) +} + +func (s *SetRoleContext) TO() antlr.TerminalNode { + return s.GetToken(MySqlParserTO, 0) +} + +func (s *SetRoleContext) NONE() antlr.TerminalNode { + return s.GetToken(MySqlParserNONE, 0) +} + +func (s *SetRoleContext) ALL() antlr.TerminalNode { + return s.GetToken(MySqlParserALL, 0) +} + +func (s *SetRoleContext) AllRoleName() []IRoleNameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRoleNameContext); ok { + len++ + } + } + + tst := make([]IRoleNameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRoleNameContext); ok { + tst[i] = t.(IRoleNameContext) + i++ + } + } + + return tst +} + +func (s *SetRoleContext) RoleName(i int) IRoleNameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRoleNameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRoleNameContext) +} + +func (s *SetRoleContext) AllUserName() []IUserNameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUserNameContext); ok { + len++ + } + } + + tst := make([]IUserNameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUserNameContext); ok { + tst[i] = t.(IUserNameContext) + i++ + } + } + + return tst +} + +func (s *SetRoleContext) UserName(i int) IUserNameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserNameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUserNameContext) +} + +func (s *SetRoleContext) AllUid() []IUidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUidContext); ok { + len++ + } + } + + tst := make([]IUidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUidContext); ok { + tst[i] = t.(IUidContext) + i++ + } + } + + return tst +} + +func (s *SetRoleContext) Uid(i int) IUidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *SetRoleContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *SetRoleContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *SetRoleContext) RoleOption() IRoleOptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRoleOptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRoleOptionContext) +} + +func (s *SetRoleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SetRoleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SetRoleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSetRole(s) + } +} + +func (s *SetRoleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSetRole(s) + } +} + +func (p *MySqlParser) SetRole() (localctx ISetRoleContext) { + localctx = NewSetRoleContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 176, MySqlParserRULE_setRole) + var _la int + + p.SetState(3142) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 409, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3109) + p.Match(MySqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3110) + p.Match(MySqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3111) + p.Match(MySqlParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3122) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 405, p.GetParserRuleContext()) { + case 1: + { + p.SetState(3112) + p.Match(MySqlParserNONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(3113) + p.Match(MySqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(3114) + p.RoleName() + } + p.SetState(3119) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(3115) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3116) + p.RoleName() + } + + p.SetState(3121) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(3124) + p.Match(MySqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3127) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 406, p.GetParserRuleContext()) { + case 1: + { + p.SetState(3125) + p.UserName() + } + + case 2: + { + p.SetState(3126) + p.Uid() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(3136) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(3129) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3132) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 407, p.GetParserRuleContext()) { + case 1: + { + p.SetState(3130) + p.UserName() + } + + case 2: + { + p.SetState(3131) + p.Uid() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(3138) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3139) + p.Match(MySqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3140) + p.Match(MySqlParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3141) + p.RoleOption() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRenameTableContext is an interface to support dynamic dispatch. +type IRenameTableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RENAME() antlr.TerminalNode + TABLE() antlr.TerminalNode + AllRenameTableClause() []IRenameTableClauseContext + RenameTableClause(i int) IRenameTableClauseContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsRenameTableContext differentiates from other interfaces. + IsRenameTableContext() +} + +type RenameTableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRenameTableContext() *RenameTableContext { + var p = new(RenameTableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_renameTable + return p +} + +func InitEmptyRenameTableContext(p *RenameTableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_renameTable +} + +func (*RenameTableContext) IsRenameTableContext() {} + +func NewRenameTableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RenameTableContext { + var p = new(RenameTableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_renameTable + + return p +} + +func (s *RenameTableContext) GetParser() antlr.Parser { return s.parser } + +func (s *RenameTableContext) RENAME() antlr.TerminalNode { + return s.GetToken(MySqlParserRENAME, 0) +} + +func (s *RenameTableContext) TABLE() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLE, 0) +} + +func (s *RenameTableContext) AllRenameTableClause() []IRenameTableClauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRenameTableClauseContext); ok { + len++ + } + } + + tst := make([]IRenameTableClauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRenameTableClauseContext); ok { + tst[i] = t.(IRenameTableClauseContext) + i++ + } + } + + return tst +} + +func (s *RenameTableContext) RenameTableClause(i int) IRenameTableClauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRenameTableClauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRenameTableClauseContext) +} + +func (s *RenameTableContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *RenameTableContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *RenameTableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RenameTableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RenameTableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterRenameTable(s) + } +} + +func (s *RenameTableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitRenameTable(s) + } +} + +func (p *MySqlParser) RenameTable() (localctx IRenameTableContext) { + localctx = NewRenameTableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 178, MySqlParserRULE_renameTable) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3144) + p.Match(MySqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3145) + p.Match(MySqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3146) + p.RenameTableClause() + } + p.SetState(3151) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(3147) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3148) + p.RenameTableClause() + } + + p.SetState(3153) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRenameTableClauseContext is an interface to support dynamic dispatch. +type IRenameTableClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllTableName() []ITableNameContext + TableName(i int) ITableNameContext + TO() antlr.TerminalNode + + // IsRenameTableClauseContext differentiates from other interfaces. + IsRenameTableClauseContext() +} + +type RenameTableClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRenameTableClauseContext() *RenameTableClauseContext { + var p = new(RenameTableClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_renameTableClause + return p +} + +func InitEmptyRenameTableClauseContext(p *RenameTableClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_renameTableClause +} + +func (*RenameTableClauseContext) IsRenameTableClauseContext() {} + +func NewRenameTableClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RenameTableClauseContext { + var p = new(RenameTableClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_renameTableClause + + return p +} + +func (s *RenameTableClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *RenameTableClauseContext) AllTableName() []ITableNameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITableNameContext); ok { + len++ + } + } + + tst := make([]ITableNameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITableNameContext); ok { + tst[i] = t.(ITableNameContext) + i++ + } + } + + return tst +} + +func (s *RenameTableClauseContext) TableName(i int) ITableNameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableNameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITableNameContext) +} + +func (s *RenameTableClauseContext) TO() antlr.TerminalNode { + return s.GetToken(MySqlParserTO, 0) +} + +func (s *RenameTableClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RenameTableClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RenameTableClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterRenameTableClause(s) + } +} + +func (s *RenameTableClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitRenameTableClause(s) + } +} + +func (p *MySqlParser) RenameTableClause() (localctx IRenameTableClauseContext) { + localctx = NewRenameTableClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 180, MySqlParserRULE_renameTableClause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3154) + p.TableName() + } + { + p.SetState(3155) + p.Match(MySqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3156) + p.TableName() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITruncateTableContext is an interface to support dynamic dispatch. +type ITruncateTableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TRUNCATE() antlr.TerminalNode + TableName() ITableNameContext + TABLE() antlr.TerminalNode + + // IsTruncateTableContext differentiates from other interfaces. + IsTruncateTableContext() +} + +type TruncateTableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTruncateTableContext() *TruncateTableContext { + var p = new(TruncateTableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_truncateTable + return p +} + +func InitEmptyTruncateTableContext(p *TruncateTableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_truncateTable +} + +func (*TruncateTableContext) IsTruncateTableContext() {} + +func NewTruncateTableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TruncateTableContext { + var p = new(TruncateTableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_truncateTable + + return p +} + +func (s *TruncateTableContext) GetParser() antlr.Parser { return s.parser } + +func (s *TruncateTableContext) TRUNCATE() antlr.TerminalNode { + return s.GetToken(MySqlParserTRUNCATE, 0) +} + +func (s *TruncateTableContext) TableName() ITableNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableNameContext) +} + +func (s *TruncateTableContext) TABLE() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLE, 0) +} + +func (s *TruncateTableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TruncateTableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TruncateTableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTruncateTable(s) + } +} + +func (s *TruncateTableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTruncateTable(s) + } +} + +func (p *MySqlParser) TruncateTable() (localctx ITruncateTableContext) { + localctx = NewTruncateTableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 182, MySqlParserRULE_truncateTable) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3158) + p.Match(MySqlParserTRUNCATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3160) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserTABLE { + { + p.SetState(3159) + p.Match(MySqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3162) + p.TableName() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICallStatementContext is an interface to support dynamic dispatch. +type ICallStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CALL() antlr.TerminalNode + FullId() IFullIdContext + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + Constants() IConstantsContext + Expressions() IExpressionsContext + + // IsCallStatementContext differentiates from other interfaces. + IsCallStatementContext() +} + +type CallStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCallStatementContext() *CallStatementContext { + var p = new(CallStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_callStatement + return p +} + +func InitEmptyCallStatementContext(p *CallStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_callStatement +} + +func (*CallStatementContext) IsCallStatementContext() {} + +func NewCallStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CallStatementContext { + var p = new(CallStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_callStatement + + return p +} + +func (s *CallStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *CallStatementContext) CALL() antlr.TerminalNode { + return s.GetToken(MySqlParserCALL, 0) +} + +func (s *CallStatementContext) FullId() IFullIdContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFullIdContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFullIdContext) +} + +func (s *CallStatementContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *CallStatementContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *CallStatementContext) Constants() IConstantsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstantsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstantsContext) +} + +func (s *CallStatementContext) Expressions() IExpressionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionsContext) +} + +func (s *CallStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CallStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CallStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCallStatement(s) + } +} + +func (s *CallStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCallStatement(s) + } +} + +func (p *MySqlParser) CallStatement() (localctx ICallStatementContext) { + localctx = NewCallStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 184, MySqlParserRULE_callStatement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3164) + p.Match(MySqlParserCALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3165) + p.FullId() + } + p.SetState(3172) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 413, p.GetParserRuleContext()) == 1 { + { + p.SetState(3166) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3169) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 412, p.GetParserRuleContext()) == 1 { + { + p.SetState(3167) + p.Constants() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 412, p.GetParserRuleContext()) == 2 { + { + p.SetState(3168) + p.Expressions() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3171) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDeleteStatementContext is an interface to support dynamic dispatch. +type IDeleteStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SingleDeleteStatement() ISingleDeleteStatementContext + MultipleDeleteStatement() IMultipleDeleteStatementContext + + // IsDeleteStatementContext differentiates from other interfaces. + IsDeleteStatementContext() +} + +type DeleteStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDeleteStatementContext() *DeleteStatementContext { + var p = new(DeleteStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_deleteStatement + return p +} + +func InitEmptyDeleteStatementContext(p *DeleteStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_deleteStatement +} + +func (*DeleteStatementContext) IsDeleteStatementContext() {} + +func NewDeleteStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DeleteStatementContext { + var p = new(DeleteStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_deleteStatement + + return p +} + +func (s *DeleteStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *DeleteStatementContext) SingleDeleteStatement() ISingleDeleteStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISingleDeleteStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISingleDeleteStatementContext) +} + +func (s *DeleteStatementContext) MultipleDeleteStatement() IMultipleDeleteStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipleDeleteStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipleDeleteStatementContext) +} + +func (s *DeleteStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DeleteStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DeleteStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterDeleteStatement(s) + } +} + +func (s *DeleteStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitDeleteStatement(s) + } +} + +func (p *MySqlParser) DeleteStatement() (localctx IDeleteStatementContext) { + localctx = NewDeleteStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 186, MySqlParserRULE_deleteStatement) + p.SetState(3176) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 414, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3174) + p.SingleDeleteStatement() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3175) + p.MultipleDeleteStatement() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDoStatementContext is an interface to support dynamic dispatch. +type IDoStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DO() antlr.TerminalNode + Expressions() IExpressionsContext + + // IsDoStatementContext differentiates from other interfaces. + IsDoStatementContext() +} + +type DoStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDoStatementContext() *DoStatementContext { + var p = new(DoStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_doStatement + return p +} + +func InitEmptyDoStatementContext(p *DoStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_doStatement +} + +func (*DoStatementContext) IsDoStatementContext() {} + +func NewDoStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DoStatementContext { + var p = new(DoStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_doStatement + + return p +} + +func (s *DoStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *DoStatementContext) DO() antlr.TerminalNode { + return s.GetToken(MySqlParserDO, 0) +} + +func (s *DoStatementContext) Expressions() IExpressionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionsContext) +} + +func (s *DoStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DoStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DoStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterDoStatement(s) + } +} + +func (s *DoStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitDoStatement(s) + } +} + +func (p *MySqlParser) DoStatement() (localctx IDoStatementContext) { + localctx = NewDoStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 188, MySqlParserRULE_doStatement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3178) + p.Match(MySqlParserDO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3179) + p.Expressions() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHandlerStatementContext is an interface to support dynamic dispatch. +type IHandlerStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + HandlerOpenStatement() IHandlerOpenStatementContext + HandlerReadIndexStatement() IHandlerReadIndexStatementContext + HandlerReadStatement() IHandlerReadStatementContext + HandlerCloseStatement() IHandlerCloseStatementContext + + // IsHandlerStatementContext differentiates from other interfaces. + IsHandlerStatementContext() +} + +type HandlerStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHandlerStatementContext() *HandlerStatementContext { + var p = new(HandlerStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_handlerStatement + return p +} + +func InitEmptyHandlerStatementContext(p *HandlerStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_handlerStatement +} + +func (*HandlerStatementContext) IsHandlerStatementContext() {} + +func NewHandlerStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *HandlerStatementContext { + var p = new(HandlerStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_handlerStatement + + return p +} + +func (s *HandlerStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *HandlerStatementContext) HandlerOpenStatement() IHandlerOpenStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHandlerOpenStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHandlerOpenStatementContext) +} + +func (s *HandlerStatementContext) HandlerReadIndexStatement() IHandlerReadIndexStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHandlerReadIndexStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHandlerReadIndexStatementContext) +} + +func (s *HandlerStatementContext) HandlerReadStatement() IHandlerReadStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHandlerReadStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHandlerReadStatementContext) +} + +func (s *HandlerStatementContext) HandlerCloseStatement() IHandlerCloseStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHandlerCloseStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHandlerCloseStatementContext) +} + +func (s *HandlerStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *HandlerStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *HandlerStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterHandlerStatement(s) + } +} + +func (s *HandlerStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitHandlerStatement(s) + } +} + +func (p *MySqlParser) HandlerStatement() (localctx IHandlerStatementContext) { + localctx = NewHandlerStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 190, MySqlParserRULE_handlerStatement) + p.SetState(3185) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 415, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3181) + p.HandlerOpenStatement() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3182) + p.HandlerReadIndexStatement() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3183) + p.HandlerReadStatement() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3184) + p.HandlerCloseStatement() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInsertStatementContext is an interface to support dynamic dispatch. +type IInsertStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPriority returns the priority token. + GetPriority() antlr.Token + + // SetPriority sets the priority token. + SetPriority(antlr.Token) + + // GetPartitions returns the partitions rule contexts. + GetPartitions() IUidListContext + + // GetColumns returns the columns rule contexts. + GetColumns() IFullColumnNameListContext + + // GetSetFirst returns the setFirst rule contexts. + GetSetFirst() IUpdatedElementContext + + // Get_updatedElement returns the _updatedElement rule contexts. + Get_updatedElement() IUpdatedElementContext + + // GetDuplicatedFirst returns the duplicatedFirst rule contexts. + GetDuplicatedFirst() IUpdatedElementContext + + // SetPartitions sets the partitions rule contexts. + SetPartitions(IUidListContext) + + // SetColumns sets the columns rule contexts. + SetColumns(IFullColumnNameListContext) + + // SetSetFirst sets the setFirst rule contexts. + SetSetFirst(IUpdatedElementContext) + + // Set_updatedElement sets the _updatedElement rule contexts. + Set_updatedElement(IUpdatedElementContext) + + // SetDuplicatedFirst sets the duplicatedFirst rule contexts. + SetDuplicatedFirst(IUpdatedElementContext) + + // GetSetElements returns the setElements rule context list. + GetSetElements() []IUpdatedElementContext + + // GetDuplicatedElements returns the duplicatedElements rule context list. + GetDuplicatedElements() []IUpdatedElementContext + + // SetSetElements sets the setElements rule context list. + SetSetElements([]IUpdatedElementContext) + + // SetDuplicatedElements sets the duplicatedElements rule context list. + SetDuplicatedElements([]IUpdatedElementContext) + + // Getter signatures + INSERT() antlr.TerminalNode + TableName() ITableNameContext + InsertStatementValue() IInsertStatementValueContext + SET() antlr.TerminalNode + IGNORE() antlr.TerminalNode + INTO() antlr.TerminalNode + PARTITION() antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + AllUpdatedElement() []IUpdatedElementContext + UpdatedElement(i int) IUpdatedElementContext + ON() antlr.TerminalNode + DUPLICATE() antlr.TerminalNode + KEY() antlr.TerminalNode + UPDATE() antlr.TerminalNode + LOW_PRIORITY() antlr.TerminalNode + DELAYED() antlr.TerminalNode + HIGH_PRIORITY() antlr.TerminalNode + Uid() IUidContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + UidList() IUidListContext + AS() antlr.TerminalNode + FullColumnNameList() IFullColumnNameListContext + + // IsInsertStatementContext differentiates from other interfaces. + IsInsertStatementContext() +} + +type InsertStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + priority antlr.Token + partitions IUidListContext + columns IFullColumnNameListContext + setFirst IUpdatedElementContext + _updatedElement IUpdatedElementContext + setElements []IUpdatedElementContext + duplicatedFirst IUpdatedElementContext + duplicatedElements []IUpdatedElementContext +} + +func NewEmptyInsertStatementContext() *InsertStatementContext { + var p = new(InsertStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_insertStatement + return p +} + +func InitEmptyInsertStatementContext(p *InsertStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_insertStatement +} + +func (*InsertStatementContext) IsInsertStatementContext() {} + +func NewInsertStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InsertStatementContext { + var p = new(InsertStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_insertStatement + + return p +} + +func (s *InsertStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *InsertStatementContext) GetPriority() antlr.Token { return s.priority } + +func (s *InsertStatementContext) SetPriority(v antlr.Token) { s.priority = v } + +func (s *InsertStatementContext) GetPartitions() IUidListContext { return s.partitions } + +func (s *InsertStatementContext) GetColumns() IFullColumnNameListContext { return s.columns } + +func (s *InsertStatementContext) GetSetFirst() IUpdatedElementContext { return s.setFirst } + +func (s *InsertStatementContext) Get_updatedElement() IUpdatedElementContext { + return s._updatedElement +} + +func (s *InsertStatementContext) GetDuplicatedFirst() IUpdatedElementContext { + return s.duplicatedFirst +} + +func (s *InsertStatementContext) SetPartitions(v IUidListContext) { s.partitions = v } + +func (s *InsertStatementContext) SetColumns(v IFullColumnNameListContext) { s.columns = v } + +func (s *InsertStatementContext) SetSetFirst(v IUpdatedElementContext) { s.setFirst = v } + +func (s *InsertStatementContext) Set_updatedElement(v IUpdatedElementContext) { s._updatedElement = v } + +func (s *InsertStatementContext) SetDuplicatedFirst(v IUpdatedElementContext) { s.duplicatedFirst = v } + +func (s *InsertStatementContext) GetSetElements() []IUpdatedElementContext { return s.setElements } + +func (s *InsertStatementContext) GetDuplicatedElements() []IUpdatedElementContext { + return s.duplicatedElements +} + +func (s *InsertStatementContext) SetSetElements(v []IUpdatedElementContext) { s.setElements = v } + +func (s *InsertStatementContext) SetDuplicatedElements(v []IUpdatedElementContext) { + s.duplicatedElements = v +} + +func (s *InsertStatementContext) INSERT() antlr.TerminalNode { + return s.GetToken(MySqlParserINSERT, 0) +} + +func (s *InsertStatementContext) TableName() ITableNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableNameContext) +} + +func (s *InsertStatementContext) InsertStatementValue() IInsertStatementValueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInsertStatementValueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInsertStatementValueContext) +} + +func (s *InsertStatementContext) SET() antlr.TerminalNode { + return s.GetToken(MySqlParserSET, 0) +} + +func (s *InsertStatementContext) IGNORE() antlr.TerminalNode { + return s.GetToken(MySqlParserIGNORE, 0) +} + +func (s *InsertStatementContext) INTO() antlr.TerminalNode { + return s.GetToken(MySqlParserINTO, 0) +} + +func (s *InsertStatementContext) PARTITION() antlr.TerminalNode { + return s.GetToken(MySqlParserPARTITION, 0) +} + +func (s *InsertStatementContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(MySqlParserLR_BRACKET) +} + +func (s *InsertStatementContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, i) +} + +func (s *InsertStatementContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(MySqlParserRR_BRACKET) +} + +func (s *InsertStatementContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, i) +} + +func (s *InsertStatementContext) AllUpdatedElement() []IUpdatedElementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUpdatedElementContext); ok { + len++ + } + } + + tst := make([]IUpdatedElementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUpdatedElementContext); ok { + tst[i] = t.(IUpdatedElementContext) + i++ + } + } + + return tst +} + +func (s *InsertStatementContext) UpdatedElement(i int) IUpdatedElementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdatedElementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUpdatedElementContext) +} + +func (s *InsertStatementContext) ON() antlr.TerminalNode { + return s.GetToken(MySqlParserON, 0) +} + +func (s *InsertStatementContext) DUPLICATE() antlr.TerminalNode { + return s.GetToken(MySqlParserDUPLICATE, 0) +} + +func (s *InsertStatementContext) KEY() antlr.TerminalNode { + return s.GetToken(MySqlParserKEY, 0) +} + +func (s *InsertStatementContext) UPDATE() antlr.TerminalNode { + return s.GetToken(MySqlParserUPDATE, 0) +} + +func (s *InsertStatementContext) LOW_PRIORITY() antlr.TerminalNode { + return s.GetToken(MySqlParserLOW_PRIORITY, 0) +} + +func (s *InsertStatementContext) DELAYED() antlr.TerminalNode { + return s.GetToken(MySqlParserDELAYED, 0) +} + +func (s *InsertStatementContext) HIGH_PRIORITY() antlr.TerminalNode { + return s.GetToken(MySqlParserHIGH_PRIORITY, 0) +} + +func (s *InsertStatementContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *InsertStatementContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *InsertStatementContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *InsertStatementContext) UidList() IUidListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidListContext) +} + +func (s *InsertStatementContext) AS() antlr.TerminalNode { + return s.GetToken(MySqlParserAS, 0) +} + +func (s *InsertStatementContext) FullColumnNameList() IFullColumnNameListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFullColumnNameListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFullColumnNameListContext) +} + +func (s *InsertStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *InsertStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *InsertStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterInsertStatement(s) + } +} + +func (s *InsertStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitInsertStatement(s) + } +} + +func (p *MySqlParser) InsertStatement() (localctx IInsertStatementContext) { + localctx = NewInsertStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 192, MySqlParserRULE_insertStatement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3187) + p.Match(MySqlParserINSERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3189) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if (int64((_la-43)) & ^0x3f) == 0 && ((int64(1)<<(_la-43))&-9223372032559808511) != 0 { + { + p.SetState(3188) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*InsertStatementContext).priority = _lt + + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-43)) & ^0x3f) == 0 && ((int64(1)<<(_la-43))&-9223372032559808511) != 0) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*InsertStatementContext).priority = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(3192) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserIGNORE { + { + p.SetState(3191) + p.Match(MySqlParserIGNORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3195) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserINTO { + { + p.SetState(3194) + p.Match(MySqlParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3197) + p.TableName() + } + p.SetState(3204) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserPARTITION { + { + p.SetState(3198) + p.Match(MySqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3199) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3201) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-34354363873) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-2199023255553) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-5764611921080745985) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-8796126576641) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-32651097298436097) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-18014398517872129) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-137438953601) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-44473063500156929) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-129) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-12289) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&-1) != 0) || ((int64((_la-1128)) & ^0x3f) == 0 && ((int64(1)<<(_la-1128))&8627683329) != 0) { + { + p.SetState(3200) + + var _x = p.UidList() + + localctx.(*InsertStatementContext).partitions = _x + } + + } + { + p.SetState(3203) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3229) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserSELECT, MySqlParserVALUES, MySqlParserVALUE, MySqlParserLR_BRACKET: + p.SetState(3211) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 422, p.GetParserRuleContext()) == 1 { + { + p.SetState(3206) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3208) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 421, p.GetParserRuleContext()) == 1 { + { + p.SetState(3207) + + var _x = p.FullColumnNameList() + + localctx.(*InsertStatementContext).columns = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3210) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3213) + p.InsertStatementValue() + } + p.SetState(3218) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 424, p.GetParserRuleContext()) == 1 { + p.SetState(3215) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserAS { + { + p.SetState(3214) + p.Match(MySqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3217) + p.Uid() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case MySqlParserSET: + { + p.SetState(3220) + p.Match(MySqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3221) + + var _x = p.UpdatedElement() + + localctx.(*InsertStatementContext).setFirst = _x + } + p.SetState(3226) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(3222) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3223) + + var _x = p.UpdatedElement() + + localctx.(*InsertStatementContext)._updatedElement = _x + } + localctx.(*InsertStatementContext).setElements = append(localctx.(*InsertStatementContext).setElements, localctx.(*InsertStatementContext)._updatedElement) + + p.SetState(3228) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(3243) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserON { + { + p.SetState(3231) + p.Match(MySqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3232) + p.Match(MySqlParserDUPLICATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3233) + p.Match(MySqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3234) + p.Match(MySqlParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3235) + + var _x = p.UpdatedElement() + + localctx.(*InsertStatementContext).duplicatedFirst = _x + } + p.SetState(3240) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(3236) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3237) + + var _x = p.UpdatedElement() + + localctx.(*InsertStatementContext)._updatedElement = _x + } + localctx.(*InsertStatementContext).duplicatedElements = append(localctx.(*InsertStatementContext).duplicatedElements, localctx.(*InsertStatementContext)._updatedElement) + + p.SetState(3242) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILoadDataStatementContext is an interface to support dynamic dispatch. +type ILoadDataStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPriority returns the priority token. + GetPriority() antlr.Token + + // GetFilename returns the filename token. + GetFilename() antlr.Token + + // GetViolation returns the violation token. + GetViolation() antlr.Token + + // GetFieldsFormat returns the fieldsFormat token. + GetFieldsFormat() antlr.Token + + // GetLinesFormat returns the linesFormat token. + GetLinesFormat() antlr.Token + + // SetPriority sets the priority token. + SetPriority(antlr.Token) + + // SetFilename sets the filename token. + SetFilename(antlr.Token) + + // SetViolation sets the violation token. + SetViolation(antlr.Token) + + // SetFieldsFormat sets the fieldsFormat token. + SetFieldsFormat(antlr.Token) + + // SetLinesFormat sets the linesFormat token. + SetLinesFormat(antlr.Token) + + // GetCharset returns the charset rule contexts. + GetCharset() ICharsetNameContext + + // SetCharset sets the charset rule contexts. + SetCharset(ICharsetNameContext) + + // Getter signatures + LOAD() antlr.TerminalNode + DATA() antlr.TerminalNode + INFILE() antlr.TerminalNode + INTO() antlr.TerminalNode + TABLE() antlr.TerminalNode + TableName() ITableNameContext + STRING_LITERAL() antlr.TerminalNode + LOCAL() antlr.TerminalNode + PARTITION() antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + UidList() IUidListContext + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + CHARACTER() antlr.TerminalNode + AllSET() []antlr.TerminalNode + SET(i int) antlr.TerminalNode + AllLINES() []antlr.TerminalNode + LINES(i int) antlr.TerminalNode + AllIGNORE() []antlr.TerminalNode + IGNORE(i int) antlr.TerminalNode + DecimalLiteral() IDecimalLiteralContext + AllAssignmentField() []IAssignmentFieldContext + AssignmentField(i int) IAssignmentFieldContext + AllUpdatedElement() []IUpdatedElementContext + UpdatedElement(i int) IUpdatedElementContext + CharsetName() ICharsetNameContext + LOW_PRIORITY() antlr.TerminalNode + CONCURRENT() antlr.TerminalNode + REPLACE() antlr.TerminalNode + FIELDS() antlr.TerminalNode + COLUMNS() antlr.TerminalNode + ROWS() antlr.TerminalNode + AllSelectFieldsInto() []ISelectFieldsIntoContext + SelectFieldsInto(i int) ISelectFieldsIntoContext + AllSelectLinesInto() []ISelectLinesIntoContext + SelectLinesInto(i int) ISelectLinesIntoContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsLoadDataStatementContext differentiates from other interfaces. + IsLoadDataStatementContext() +} + +type LoadDataStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + priority antlr.Token + filename antlr.Token + violation antlr.Token + charset ICharsetNameContext + fieldsFormat antlr.Token + linesFormat antlr.Token +} + +func NewEmptyLoadDataStatementContext() *LoadDataStatementContext { + var p = new(LoadDataStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_loadDataStatement + return p +} + +func InitEmptyLoadDataStatementContext(p *LoadDataStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_loadDataStatement +} + +func (*LoadDataStatementContext) IsLoadDataStatementContext() {} + +func NewLoadDataStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LoadDataStatementContext { + var p = new(LoadDataStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_loadDataStatement + + return p +} + +func (s *LoadDataStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *LoadDataStatementContext) GetPriority() antlr.Token { return s.priority } + +func (s *LoadDataStatementContext) GetFilename() antlr.Token { return s.filename } + +func (s *LoadDataStatementContext) GetViolation() antlr.Token { return s.violation } + +func (s *LoadDataStatementContext) GetFieldsFormat() antlr.Token { return s.fieldsFormat } + +func (s *LoadDataStatementContext) GetLinesFormat() antlr.Token { return s.linesFormat } + +func (s *LoadDataStatementContext) SetPriority(v antlr.Token) { s.priority = v } + +func (s *LoadDataStatementContext) SetFilename(v antlr.Token) { s.filename = v } + +func (s *LoadDataStatementContext) SetViolation(v antlr.Token) { s.violation = v } + +func (s *LoadDataStatementContext) SetFieldsFormat(v antlr.Token) { s.fieldsFormat = v } + +func (s *LoadDataStatementContext) SetLinesFormat(v antlr.Token) { s.linesFormat = v } + +func (s *LoadDataStatementContext) GetCharset() ICharsetNameContext { return s.charset } + +func (s *LoadDataStatementContext) SetCharset(v ICharsetNameContext) { s.charset = v } + +func (s *LoadDataStatementContext) LOAD() antlr.TerminalNode { + return s.GetToken(MySqlParserLOAD, 0) +} + +func (s *LoadDataStatementContext) DATA() antlr.TerminalNode { + return s.GetToken(MySqlParserDATA, 0) +} + +func (s *LoadDataStatementContext) INFILE() antlr.TerminalNode { + return s.GetToken(MySqlParserINFILE, 0) +} + +func (s *LoadDataStatementContext) INTO() antlr.TerminalNode { + return s.GetToken(MySqlParserINTO, 0) +} + +func (s *LoadDataStatementContext) TABLE() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLE, 0) +} + +func (s *LoadDataStatementContext) TableName() ITableNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableNameContext) +} + +func (s *LoadDataStatementContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *LoadDataStatementContext) LOCAL() antlr.TerminalNode { + return s.GetToken(MySqlParserLOCAL, 0) +} + +func (s *LoadDataStatementContext) PARTITION() antlr.TerminalNode { + return s.GetToken(MySqlParserPARTITION, 0) +} + +func (s *LoadDataStatementContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(MySqlParserLR_BRACKET) +} + +func (s *LoadDataStatementContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, i) +} + +func (s *LoadDataStatementContext) UidList() IUidListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidListContext) +} + +func (s *LoadDataStatementContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(MySqlParserRR_BRACKET) +} + +func (s *LoadDataStatementContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, i) +} + +func (s *LoadDataStatementContext) CHARACTER() antlr.TerminalNode { + return s.GetToken(MySqlParserCHARACTER, 0) +} + +func (s *LoadDataStatementContext) AllSET() []antlr.TerminalNode { + return s.GetTokens(MySqlParserSET) +} + +func (s *LoadDataStatementContext) SET(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserSET, i) +} + +func (s *LoadDataStatementContext) AllLINES() []antlr.TerminalNode { + return s.GetTokens(MySqlParserLINES) +} + +func (s *LoadDataStatementContext) LINES(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserLINES, i) +} + +func (s *LoadDataStatementContext) AllIGNORE() []antlr.TerminalNode { + return s.GetTokens(MySqlParserIGNORE) +} + +func (s *LoadDataStatementContext) IGNORE(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserIGNORE, i) +} + +func (s *LoadDataStatementContext) DecimalLiteral() IDecimalLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *LoadDataStatementContext) AllAssignmentField() []IAssignmentFieldContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAssignmentFieldContext); ok { + len++ + } + } + + tst := make([]IAssignmentFieldContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAssignmentFieldContext); ok { + tst[i] = t.(IAssignmentFieldContext) + i++ + } + } + + return tst +} + +func (s *LoadDataStatementContext) AssignmentField(i int) IAssignmentFieldContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAssignmentFieldContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAssignmentFieldContext) +} + +func (s *LoadDataStatementContext) AllUpdatedElement() []IUpdatedElementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUpdatedElementContext); ok { + len++ + } + } + + tst := make([]IUpdatedElementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUpdatedElementContext); ok { + tst[i] = t.(IUpdatedElementContext) + i++ + } + } + + return tst +} + +func (s *LoadDataStatementContext) UpdatedElement(i int) IUpdatedElementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdatedElementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUpdatedElementContext) +} + +func (s *LoadDataStatementContext) CharsetName() ICharsetNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICharsetNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICharsetNameContext) +} + +func (s *LoadDataStatementContext) LOW_PRIORITY() antlr.TerminalNode { + return s.GetToken(MySqlParserLOW_PRIORITY, 0) +} + +func (s *LoadDataStatementContext) CONCURRENT() antlr.TerminalNode { + return s.GetToken(MySqlParserCONCURRENT, 0) +} + +func (s *LoadDataStatementContext) REPLACE() antlr.TerminalNode { + return s.GetToken(MySqlParserREPLACE, 0) +} + +func (s *LoadDataStatementContext) FIELDS() antlr.TerminalNode { + return s.GetToken(MySqlParserFIELDS, 0) +} + +func (s *LoadDataStatementContext) COLUMNS() antlr.TerminalNode { + return s.GetToken(MySqlParserCOLUMNS, 0) +} + +func (s *LoadDataStatementContext) ROWS() antlr.TerminalNode { + return s.GetToken(MySqlParserROWS, 0) +} + +func (s *LoadDataStatementContext) AllSelectFieldsInto() []ISelectFieldsIntoContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISelectFieldsIntoContext); ok { + len++ + } + } + + tst := make([]ISelectFieldsIntoContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISelectFieldsIntoContext); ok { + tst[i] = t.(ISelectFieldsIntoContext) + i++ + } + } + + return tst +} + +func (s *LoadDataStatementContext) SelectFieldsInto(i int) ISelectFieldsIntoContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelectFieldsIntoContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISelectFieldsIntoContext) +} + +func (s *LoadDataStatementContext) AllSelectLinesInto() []ISelectLinesIntoContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISelectLinesIntoContext); ok { + len++ + } + } + + tst := make([]ISelectLinesIntoContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISelectLinesIntoContext); ok { + tst[i] = t.(ISelectLinesIntoContext) + i++ + } + } + + return tst +} + +func (s *LoadDataStatementContext) SelectLinesInto(i int) ISelectLinesIntoContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelectLinesIntoContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISelectLinesIntoContext) +} + +func (s *LoadDataStatementContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *LoadDataStatementContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *LoadDataStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LoadDataStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *LoadDataStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterLoadDataStatement(s) + } +} + +func (s *LoadDataStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitLoadDataStatement(s) + } +} + +func (p *MySqlParser) LoadDataStatement() (localctx ILoadDataStatementContext) { + localctx = NewLoadDataStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 194, MySqlParserRULE_loadDataStatement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3245) + p.Match(MySqlParserLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3246) + p.Match(MySqlParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3248) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserLOW_PRIORITY || _la == MySqlParserCONCURRENT { + { + p.SetState(3247) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*LoadDataStatementContext).priority = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserLOW_PRIORITY || _la == MySqlParserCONCURRENT) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*LoadDataStatementContext).priority = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(3251) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserLOCAL { + { + p.SetState(3250) + p.Match(MySqlParserLOCAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3253) + p.Match(MySqlParserINFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3254) + + var _m = p.Match(MySqlParserSTRING_LITERAL) + + localctx.(*LoadDataStatementContext).filename = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3256) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserIGNORE || _la == MySqlParserREPLACE { + { + p.SetState(3255) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*LoadDataStatementContext).violation = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserIGNORE || _la == MySqlParserREPLACE) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*LoadDataStatementContext).violation = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(3258) + p.Match(MySqlParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3259) + p.Match(MySqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3260) + p.TableName() + } + p.SetState(3266) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserPARTITION { + { + p.SetState(3261) + p.Match(MySqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3262) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3263) + p.UidList() + } + { + p.SetState(3264) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3271) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserCHARACTER { + { + p.SetState(3268) + p.Match(MySqlParserCHARACTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3269) + p.Match(MySqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3270) + + var _x = p.CharsetName() + + localctx.(*LoadDataStatementContext).charset = _x + } + + } + p.SetState(3279) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserCOLUMNS || _la == MySqlParserFIELDS { + { + p.SetState(3273) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*LoadDataStatementContext).fieldsFormat = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserCOLUMNS || _la == MySqlParserFIELDS) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*LoadDataStatementContext).fieldsFormat = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(3275) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == MySqlParserENCLOSED || _la == MySqlParserESCAPED || _la == MySqlParserOPTIONALLY || _la == MySqlParserTERMINATED { + { + p.SetState(3274) + p.SelectFieldsInto() + } + + p.SetState(3277) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + p.SetState(3287) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserLINES { + { + p.SetState(3281) + p.Match(MySqlParserLINES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3283) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == MySqlParserSTARTING || _la == MySqlParserTERMINATED { + { + p.SetState(3282) + p.SelectLinesInto() + } + + p.SetState(3285) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + p.SetState(3293) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserIGNORE { + { + p.SetState(3289) + p.Match(MySqlParserIGNORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3290) + p.DecimalLiteral() + } + { + p.SetState(3291) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*LoadDataStatementContext).linesFormat = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserLINES || _la == MySqlParserROWS) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*LoadDataStatementContext).linesFormat = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(3306) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 440, p.GetParserRuleContext()) == 1 { + { + p.SetState(3295) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3296) + p.AssignmentField() + } + p.SetState(3301) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(3297) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3298) + p.AssignmentField() + } + + p.SetState(3303) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3304) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3317) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 442, p.GetParserRuleContext()) == 1 { + { + p.SetState(3308) + p.Match(MySqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3309) + p.UpdatedElement() + } + p.SetState(3314) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(3310) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3311) + p.UpdatedElement() + } + + p.SetState(3316) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILoadXmlStatementContext is an interface to support dynamic dispatch. +type ILoadXmlStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPriority returns the priority token. + GetPriority() antlr.Token + + // GetFilename returns the filename token. + GetFilename() antlr.Token + + // GetViolation returns the violation token. + GetViolation() antlr.Token + + // GetTag returns the tag token. + GetTag() antlr.Token + + // GetLinesFormat returns the linesFormat token. + GetLinesFormat() antlr.Token + + // SetPriority sets the priority token. + SetPriority(antlr.Token) + + // SetFilename sets the filename token. + SetFilename(antlr.Token) + + // SetViolation sets the violation token. + SetViolation(antlr.Token) + + // SetTag sets the tag token. + SetTag(antlr.Token) + + // SetLinesFormat sets the linesFormat token. + SetLinesFormat(antlr.Token) + + // GetCharset returns the charset rule contexts. + GetCharset() ICharsetNameContext + + // SetCharset sets the charset rule contexts. + SetCharset(ICharsetNameContext) + + // Getter signatures + LOAD() antlr.TerminalNode + XML() antlr.TerminalNode + INFILE() antlr.TerminalNode + INTO() antlr.TerminalNode + TABLE() antlr.TerminalNode + TableName() ITableNameContext + AllSTRING_LITERAL() []antlr.TerminalNode + STRING_LITERAL(i int) antlr.TerminalNode + LOCAL() antlr.TerminalNode + CHARACTER() antlr.TerminalNode + AllSET() []antlr.TerminalNode + SET(i int) antlr.TerminalNode + AllROWS() []antlr.TerminalNode + ROWS(i int) antlr.TerminalNode + IDENTIFIED() antlr.TerminalNode + BY() antlr.TerminalNode + LESS_SYMBOL() antlr.TerminalNode + GREATER_SYMBOL() antlr.TerminalNode + AllIGNORE() []antlr.TerminalNode + IGNORE(i int) antlr.TerminalNode + DecimalLiteral() IDecimalLiteralContext + LR_BRACKET() antlr.TerminalNode + AllAssignmentField() []IAssignmentFieldContext + AssignmentField(i int) IAssignmentFieldContext + RR_BRACKET() antlr.TerminalNode + AllUpdatedElement() []IUpdatedElementContext + UpdatedElement(i int) IUpdatedElementContext + CharsetName() ICharsetNameContext + LOW_PRIORITY() antlr.TerminalNode + CONCURRENT() antlr.TerminalNode + REPLACE() antlr.TerminalNode + LINES() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsLoadXmlStatementContext differentiates from other interfaces. + IsLoadXmlStatementContext() +} + +type LoadXmlStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + priority antlr.Token + filename antlr.Token + violation antlr.Token + charset ICharsetNameContext + tag antlr.Token + linesFormat antlr.Token +} + +func NewEmptyLoadXmlStatementContext() *LoadXmlStatementContext { + var p = new(LoadXmlStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_loadXmlStatement + return p +} + +func InitEmptyLoadXmlStatementContext(p *LoadXmlStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_loadXmlStatement +} + +func (*LoadXmlStatementContext) IsLoadXmlStatementContext() {} + +func NewLoadXmlStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LoadXmlStatementContext { + var p = new(LoadXmlStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_loadXmlStatement + + return p +} + +func (s *LoadXmlStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *LoadXmlStatementContext) GetPriority() antlr.Token { return s.priority } + +func (s *LoadXmlStatementContext) GetFilename() antlr.Token { return s.filename } + +func (s *LoadXmlStatementContext) GetViolation() antlr.Token { return s.violation } + +func (s *LoadXmlStatementContext) GetTag() antlr.Token { return s.tag } + +func (s *LoadXmlStatementContext) GetLinesFormat() antlr.Token { return s.linesFormat } + +func (s *LoadXmlStatementContext) SetPriority(v antlr.Token) { s.priority = v } + +func (s *LoadXmlStatementContext) SetFilename(v antlr.Token) { s.filename = v } + +func (s *LoadXmlStatementContext) SetViolation(v antlr.Token) { s.violation = v } + +func (s *LoadXmlStatementContext) SetTag(v antlr.Token) { s.tag = v } + +func (s *LoadXmlStatementContext) SetLinesFormat(v antlr.Token) { s.linesFormat = v } + +func (s *LoadXmlStatementContext) GetCharset() ICharsetNameContext { return s.charset } + +func (s *LoadXmlStatementContext) SetCharset(v ICharsetNameContext) { s.charset = v } + +func (s *LoadXmlStatementContext) LOAD() antlr.TerminalNode { + return s.GetToken(MySqlParserLOAD, 0) +} + +func (s *LoadXmlStatementContext) XML() antlr.TerminalNode { + return s.GetToken(MySqlParserXML, 0) +} + +func (s *LoadXmlStatementContext) INFILE() antlr.TerminalNode { + return s.GetToken(MySqlParserINFILE, 0) +} + +func (s *LoadXmlStatementContext) INTO() antlr.TerminalNode { + return s.GetToken(MySqlParserINTO, 0) +} + +func (s *LoadXmlStatementContext) TABLE() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLE, 0) +} + +func (s *LoadXmlStatementContext) TableName() ITableNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableNameContext) +} + +func (s *LoadXmlStatementContext) AllSTRING_LITERAL() []antlr.TerminalNode { + return s.GetTokens(MySqlParserSTRING_LITERAL) +} + +func (s *LoadXmlStatementContext) STRING_LITERAL(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, i) +} + +func (s *LoadXmlStatementContext) LOCAL() antlr.TerminalNode { + return s.GetToken(MySqlParserLOCAL, 0) +} + +func (s *LoadXmlStatementContext) CHARACTER() antlr.TerminalNode { + return s.GetToken(MySqlParserCHARACTER, 0) +} + +func (s *LoadXmlStatementContext) AllSET() []antlr.TerminalNode { + return s.GetTokens(MySqlParserSET) +} + +func (s *LoadXmlStatementContext) SET(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserSET, i) +} + +func (s *LoadXmlStatementContext) AllROWS() []antlr.TerminalNode { + return s.GetTokens(MySqlParserROWS) +} + +func (s *LoadXmlStatementContext) ROWS(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserROWS, i) +} + +func (s *LoadXmlStatementContext) IDENTIFIED() antlr.TerminalNode { + return s.GetToken(MySqlParserIDENTIFIED, 0) +} + +func (s *LoadXmlStatementContext) BY() antlr.TerminalNode { + return s.GetToken(MySqlParserBY, 0) +} + +func (s *LoadXmlStatementContext) LESS_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserLESS_SYMBOL, 0) +} + +func (s *LoadXmlStatementContext) GREATER_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserGREATER_SYMBOL, 0) +} + +func (s *LoadXmlStatementContext) AllIGNORE() []antlr.TerminalNode { + return s.GetTokens(MySqlParserIGNORE) +} + +func (s *LoadXmlStatementContext) IGNORE(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserIGNORE, i) +} + +func (s *LoadXmlStatementContext) DecimalLiteral() IDecimalLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *LoadXmlStatementContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *LoadXmlStatementContext) AllAssignmentField() []IAssignmentFieldContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAssignmentFieldContext); ok { + len++ + } + } + + tst := make([]IAssignmentFieldContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAssignmentFieldContext); ok { + tst[i] = t.(IAssignmentFieldContext) + i++ + } + } + + return tst +} + +func (s *LoadXmlStatementContext) AssignmentField(i int) IAssignmentFieldContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAssignmentFieldContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAssignmentFieldContext) +} + +func (s *LoadXmlStatementContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *LoadXmlStatementContext) AllUpdatedElement() []IUpdatedElementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUpdatedElementContext); ok { + len++ + } + } + + tst := make([]IUpdatedElementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUpdatedElementContext); ok { + tst[i] = t.(IUpdatedElementContext) + i++ + } + } + + return tst +} + +func (s *LoadXmlStatementContext) UpdatedElement(i int) IUpdatedElementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdatedElementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUpdatedElementContext) +} + +func (s *LoadXmlStatementContext) CharsetName() ICharsetNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICharsetNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICharsetNameContext) +} + +func (s *LoadXmlStatementContext) LOW_PRIORITY() antlr.TerminalNode { + return s.GetToken(MySqlParserLOW_PRIORITY, 0) +} + +func (s *LoadXmlStatementContext) CONCURRENT() antlr.TerminalNode { + return s.GetToken(MySqlParserCONCURRENT, 0) +} + +func (s *LoadXmlStatementContext) REPLACE() antlr.TerminalNode { + return s.GetToken(MySqlParserREPLACE, 0) +} + +func (s *LoadXmlStatementContext) LINES() antlr.TerminalNode { + return s.GetToken(MySqlParserLINES, 0) +} + +func (s *LoadXmlStatementContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *LoadXmlStatementContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *LoadXmlStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LoadXmlStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *LoadXmlStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterLoadXmlStatement(s) + } +} + +func (s *LoadXmlStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitLoadXmlStatement(s) + } +} + +func (p *MySqlParser) LoadXmlStatement() (localctx ILoadXmlStatementContext) { + localctx = NewLoadXmlStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 196, MySqlParserRULE_loadXmlStatement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3319) + p.Match(MySqlParserLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3320) + p.Match(MySqlParserXML) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3322) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserLOW_PRIORITY || _la == MySqlParserCONCURRENT { + { + p.SetState(3321) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*LoadXmlStatementContext).priority = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserLOW_PRIORITY || _la == MySqlParserCONCURRENT) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*LoadXmlStatementContext).priority = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(3325) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserLOCAL { + { + p.SetState(3324) + p.Match(MySqlParserLOCAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3327) + p.Match(MySqlParserINFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3328) + + var _m = p.Match(MySqlParserSTRING_LITERAL) + + localctx.(*LoadXmlStatementContext).filename = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3330) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserIGNORE || _la == MySqlParserREPLACE { + { + p.SetState(3329) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*LoadXmlStatementContext).violation = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserIGNORE || _la == MySqlParserREPLACE) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*LoadXmlStatementContext).violation = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(3332) + p.Match(MySqlParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3333) + p.Match(MySqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3334) + p.TableName() + } + p.SetState(3338) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserCHARACTER { + { + p.SetState(3335) + p.Match(MySqlParserCHARACTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3336) + p.Match(MySqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3337) + + var _x = p.CharsetName() + + localctx.(*LoadXmlStatementContext).charset = _x + } + + } + p.SetState(3346) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserROWS { + { + p.SetState(3340) + p.Match(MySqlParserROWS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3341) + p.Match(MySqlParserIDENTIFIED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3342) + p.Match(MySqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3343) + p.Match(MySqlParserLESS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3344) + + var _m = p.Match(MySqlParserSTRING_LITERAL) + + localctx.(*LoadXmlStatementContext).tag = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3345) + p.Match(MySqlParserGREATER_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3352) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserIGNORE { + { + p.SetState(3348) + p.Match(MySqlParserIGNORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3349) + p.DecimalLiteral() + } + { + p.SetState(3350) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*LoadXmlStatementContext).linesFormat = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserLINES || _la == MySqlParserROWS) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*LoadXmlStatementContext).linesFormat = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(3365) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 450, p.GetParserRuleContext()) == 1 { + { + p.SetState(3354) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3355) + p.AssignmentField() + } + p.SetState(3360) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(3356) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3357) + p.AssignmentField() + } + + p.SetState(3362) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3363) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3376) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 452, p.GetParserRuleContext()) == 1 { + { + p.SetState(3367) + p.Match(MySqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3368) + p.UpdatedElement() + } + p.SetState(3373) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(3369) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3370) + p.UpdatedElement() + } + + p.SetState(3375) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReplaceStatementContext is an interface to support dynamic dispatch. +type IReplaceStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPriority returns the priority token. + GetPriority() antlr.Token + + // SetPriority sets the priority token. + SetPriority(antlr.Token) + + // GetPartitions returns the partitions rule contexts. + GetPartitions() IUidListContext + + // GetColumns returns the columns rule contexts. + GetColumns() IUidListContext + + // GetSetFirst returns the setFirst rule contexts. + GetSetFirst() IUpdatedElementContext + + // Get_updatedElement returns the _updatedElement rule contexts. + Get_updatedElement() IUpdatedElementContext + + // SetPartitions sets the partitions rule contexts. + SetPartitions(IUidListContext) + + // SetColumns sets the columns rule contexts. + SetColumns(IUidListContext) + + // SetSetFirst sets the setFirst rule contexts. + SetSetFirst(IUpdatedElementContext) + + // Set_updatedElement sets the _updatedElement rule contexts. + Set_updatedElement(IUpdatedElementContext) + + // GetSetElements returns the setElements rule context list. + GetSetElements() []IUpdatedElementContext + + // SetSetElements sets the setElements rule context list. + SetSetElements([]IUpdatedElementContext) + + // Getter signatures + REPLACE() antlr.TerminalNode + TableName() ITableNameContext + InsertStatementValue() IInsertStatementValueContext + SET() antlr.TerminalNode + INTO() antlr.TerminalNode + PARTITION() antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + AllUpdatedElement() []IUpdatedElementContext + UpdatedElement(i int) IUpdatedElementContext + AllUidList() []IUidListContext + UidList(i int) IUidListContext + LOW_PRIORITY() antlr.TerminalNode + DELAYED() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsReplaceStatementContext differentiates from other interfaces. + IsReplaceStatementContext() +} + +type ReplaceStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + priority antlr.Token + partitions IUidListContext + columns IUidListContext + setFirst IUpdatedElementContext + _updatedElement IUpdatedElementContext + setElements []IUpdatedElementContext +} + +func NewEmptyReplaceStatementContext() *ReplaceStatementContext { + var p = new(ReplaceStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_replaceStatement + return p +} + +func InitEmptyReplaceStatementContext(p *ReplaceStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_replaceStatement +} + +func (*ReplaceStatementContext) IsReplaceStatementContext() {} + +func NewReplaceStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReplaceStatementContext { + var p = new(ReplaceStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_replaceStatement + + return p +} + +func (s *ReplaceStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *ReplaceStatementContext) GetPriority() antlr.Token { return s.priority } + +func (s *ReplaceStatementContext) SetPriority(v antlr.Token) { s.priority = v } + +func (s *ReplaceStatementContext) GetPartitions() IUidListContext { return s.partitions } + +func (s *ReplaceStatementContext) GetColumns() IUidListContext { return s.columns } + +func (s *ReplaceStatementContext) GetSetFirst() IUpdatedElementContext { return s.setFirst } + +func (s *ReplaceStatementContext) Get_updatedElement() IUpdatedElementContext { + return s._updatedElement +} + +func (s *ReplaceStatementContext) SetPartitions(v IUidListContext) { s.partitions = v } + +func (s *ReplaceStatementContext) SetColumns(v IUidListContext) { s.columns = v } + +func (s *ReplaceStatementContext) SetSetFirst(v IUpdatedElementContext) { s.setFirst = v } + +func (s *ReplaceStatementContext) Set_updatedElement(v IUpdatedElementContext) { s._updatedElement = v } + +func (s *ReplaceStatementContext) GetSetElements() []IUpdatedElementContext { return s.setElements } + +func (s *ReplaceStatementContext) SetSetElements(v []IUpdatedElementContext) { s.setElements = v } + +func (s *ReplaceStatementContext) REPLACE() antlr.TerminalNode { + return s.GetToken(MySqlParserREPLACE, 0) +} + +func (s *ReplaceStatementContext) TableName() ITableNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableNameContext) +} + +func (s *ReplaceStatementContext) InsertStatementValue() IInsertStatementValueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInsertStatementValueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInsertStatementValueContext) +} + +func (s *ReplaceStatementContext) SET() antlr.TerminalNode { + return s.GetToken(MySqlParserSET, 0) +} + +func (s *ReplaceStatementContext) INTO() antlr.TerminalNode { + return s.GetToken(MySqlParserINTO, 0) +} + +func (s *ReplaceStatementContext) PARTITION() antlr.TerminalNode { + return s.GetToken(MySqlParserPARTITION, 0) +} + +func (s *ReplaceStatementContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(MySqlParserLR_BRACKET) +} + +func (s *ReplaceStatementContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, i) +} + +func (s *ReplaceStatementContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(MySqlParserRR_BRACKET) +} + +func (s *ReplaceStatementContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, i) +} + +func (s *ReplaceStatementContext) AllUpdatedElement() []IUpdatedElementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUpdatedElementContext); ok { + len++ + } + } + + tst := make([]IUpdatedElementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUpdatedElementContext); ok { + tst[i] = t.(IUpdatedElementContext) + i++ + } + } + + return tst +} + +func (s *ReplaceStatementContext) UpdatedElement(i int) IUpdatedElementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdatedElementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUpdatedElementContext) +} + +func (s *ReplaceStatementContext) AllUidList() []IUidListContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUidListContext); ok { + len++ + } + } + + tst := make([]IUidListContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUidListContext); ok { + tst[i] = t.(IUidListContext) + i++ + } + } + + return tst +} + +func (s *ReplaceStatementContext) UidList(i int) IUidListContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidListContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUidListContext) +} + +func (s *ReplaceStatementContext) LOW_PRIORITY() antlr.TerminalNode { + return s.GetToken(MySqlParserLOW_PRIORITY, 0) +} + +func (s *ReplaceStatementContext) DELAYED() antlr.TerminalNode { + return s.GetToken(MySqlParserDELAYED, 0) +} + +func (s *ReplaceStatementContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *ReplaceStatementContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *ReplaceStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ReplaceStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ReplaceStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterReplaceStatement(s) + } +} + +func (s *ReplaceStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitReplaceStatement(s) + } +} + +func (p *MySqlParser) ReplaceStatement() (localctx IReplaceStatementContext) { + localctx = NewReplaceStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 198, MySqlParserRULE_replaceStatement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3378) + p.Match(MySqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3380) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserDELAYED || _la == MySqlParserLOW_PRIORITY { + { + p.SetState(3379) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*ReplaceStatementContext).priority = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserDELAYED || _la == MySqlParserLOW_PRIORITY) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*ReplaceStatementContext).priority = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(3383) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserINTO { + { + p.SetState(3382) + p.Match(MySqlParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3385) + p.TableName() + } + p.SetState(3391) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserPARTITION { + { + p.SetState(3386) + p.Match(MySqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3387) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3388) + + var _x = p.UidList() + + localctx.(*ReplaceStatementContext).partitions = _x + } + { + p.SetState(3389) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3409) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserSELECT, MySqlParserVALUES, MySqlParserVALUE, MySqlParserLR_BRACKET: + p.SetState(3397) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 456, p.GetParserRuleContext()) == 1 { + { + p.SetState(3393) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3394) + + var _x = p.UidList() + + localctx.(*ReplaceStatementContext).columns = _x + } + { + p.SetState(3395) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3399) + p.InsertStatementValue() + } + + case MySqlParserSET: + { + p.SetState(3400) + p.Match(MySqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3401) + + var _x = p.UpdatedElement() + + localctx.(*ReplaceStatementContext).setFirst = _x + } + p.SetState(3406) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(3402) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3403) + + var _x = p.UpdatedElement() + + localctx.(*ReplaceStatementContext)._updatedElement = _x + } + localctx.(*ReplaceStatementContext).setElements = append(localctx.(*ReplaceStatementContext).setElements, localctx.(*ReplaceStatementContext)._updatedElement) + + p.SetState(3408) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISelectStatementContext is an interface to support dynamic dispatch. +type ISelectStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsSelectStatementContext differentiates from other interfaces. + IsSelectStatementContext() +} + +type SelectStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelectStatementContext() *SelectStatementContext { + var p = new(SelectStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_selectStatement + return p +} + +func InitEmptySelectStatementContext(p *SelectStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_selectStatement +} + +func (*SelectStatementContext) IsSelectStatementContext() {} + +func NewSelectStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SelectStatementContext { + var p = new(SelectStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_selectStatement + + return p +} + +func (s *SelectStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *SelectStatementContext) CopyAll(ctx *SelectStatementContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *SelectStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SelectStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type UnionSelectContext struct { + SelectStatementContext + unionType antlr.Token +} + +func NewUnionSelectContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *UnionSelectContext { + var p = new(UnionSelectContext) + + InitEmptySelectStatementContext(&p.SelectStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SelectStatementContext)) + + return p +} + +func (s *UnionSelectContext) GetUnionType() antlr.Token { return s.unionType } + +func (s *UnionSelectContext) SetUnionType(v antlr.Token) { s.unionType = v } + +func (s *UnionSelectContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UnionSelectContext) QuerySpecificationNointo() IQuerySpecificationNointoContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuerySpecificationNointoContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuerySpecificationNointoContext) +} + +func (s *UnionSelectContext) QueryExpressionNointo() IQueryExpressionNointoContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQueryExpressionNointoContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQueryExpressionNointoContext) +} + +func (s *UnionSelectContext) AllUnionStatement() []IUnionStatementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUnionStatementContext); ok { + len++ + } + } + + tst := make([]IUnionStatementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUnionStatementContext); ok { + tst[i] = t.(IUnionStatementContext) + i++ + } + } + + return tst +} + +func (s *UnionSelectContext) UnionStatement(i int) IUnionStatementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnionStatementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUnionStatementContext) +} + +func (s *UnionSelectContext) UNION() antlr.TerminalNode { + return s.GetToken(MySqlParserUNION, 0) +} + +func (s *UnionSelectContext) OrderByClause() IOrderByClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOrderByClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOrderByClauseContext) +} + +func (s *UnionSelectContext) LimitClause() ILimitClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILimitClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILimitClauseContext) +} + +func (s *UnionSelectContext) LockClause() ILockClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILockClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILockClauseContext) +} + +func (s *UnionSelectContext) QuerySpecification() IQuerySpecificationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuerySpecificationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuerySpecificationContext) +} + +func (s *UnionSelectContext) QueryExpression() IQueryExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQueryExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQueryExpressionContext) +} + +func (s *UnionSelectContext) ALL() antlr.TerminalNode { + return s.GetToken(MySqlParserALL, 0) +} + +func (s *UnionSelectContext) DISTINCT() antlr.TerminalNode { + return s.GetToken(MySqlParserDISTINCT, 0) +} + +func (s *UnionSelectContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterUnionSelect(s) + } +} + +func (s *UnionSelectContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitUnionSelect(s) + } +} + +type UnionParenthesisSelectContext struct { + SelectStatementContext + unionType antlr.Token +} + +func NewUnionParenthesisSelectContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *UnionParenthesisSelectContext { + var p = new(UnionParenthesisSelectContext) + + InitEmptySelectStatementContext(&p.SelectStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SelectStatementContext)) + + return p +} + +func (s *UnionParenthesisSelectContext) GetUnionType() antlr.Token { return s.unionType } + +func (s *UnionParenthesisSelectContext) SetUnionType(v antlr.Token) { s.unionType = v } + +func (s *UnionParenthesisSelectContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UnionParenthesisSelectContext) QueryExpressionNointo() IQueryExpressionNointoContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQueryExpressionNointoContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQueryExpressionNointoContext) +} + +func (s *UnionParenthesisSelectContext) AllUnionParenthesis() []IUnionParenthesisContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUnionParenthesisContext); ok { + len++ + } + } + + tst := make([]IUnionParenthesisContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUnionParenthesisContext); ok { + tst[i] = t.(IUnionParenthesisContext) + i++ + } + } + + return tst +} + +func (s *UnionParenthesisSelectContext) UnionParenthesis(i int) IUnionParenthesisContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnionParenthesisContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUnionParenthesisContext) +} + +func (s *UnionParenthesisSelectContext) UNION() antlr.TerminalNode { + return s.GetToken(MySqlParserUNION, 0) +} + +func (s *UnionParenthesisSelectContext) QueryExpression() IQueryExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQueryExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQueryExpressionContext) +} + +func (s *UnionParenthesisSelectContext) OrderByClause() IOrderByClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOrderByClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOrderByClauseContext) +} + +func (s *UnionParenthesisSelectContext) LimitClause() ILimitClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILimitClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILimitClauseContext) +} + +func (s *UnionParenthesisSelectContext) LockClause() ILockClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILockClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILockClauseContext) +} + +func (s *UnionParenthesisSelectContext) ALL() antlr.TerminalNode { + return s.GetToken(MySqlParserALL, 0) +} + +func (s *UnionParenthesisSelectContext) DISTINCT() antlr.TerminalNode { + return s.GetToken(MySqlParserDISTINCT, 0) +} + +func (s *UnionParenthesisSelectContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterUnionParenthesisSelect(s) + } +} + +func (s *UnionParenthesisSelectContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitUnionParenthesisSelect(s) + } +} + +type SimpleSelectContext struct { + SelectStatementContext +} + +func NewSimpleSelectContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SimpleSelectContext { + var p = new(SimpleSelectContext) + + InitEmptySelectStatementContext(&p.SelectStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SelectStatementContext)) + + return p +} + +func (s *SimpleSelectContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SimpleSelectContext) QuerySpecification() IQuerySpecificationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuerySpecificationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuerySpecificationContext) +} + +func (s *SimpleSelectContext) LockClause() ILockClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILockClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILockClauseContext) +} + +func (s *SimpleSelectContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSimpleSelect(s) + } +} + +func (s *SimpleSelectContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSimpleSelect(s) + } +} + +type ParenthesisSelectContext struct { + SelectStatementContext +} + +func NewParenthesisSelectContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ParenthesisSelectContext { + var p = new(ParenthesisSelectContext) + + InitEmptySelectStatementContext(&p.SelectStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SelectStatementContext)) + + return p +} + +func (s *ParenthesisSelectContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ParenthesisSelectContext) QueryExpression() IQueryExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQueryExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQueryExpressionContext) +} + +func (s *ParenthesisSelectContext) LockClause() ILockClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILockClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILockClauseContext) +} + +func (s *ParenthesisSelectContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterParenthesisSelect(s) + } +} + +func (s *ParenthesisSelectContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitParenthesisSelect(s) + } +} + +type WithLateralStatementContext struct { + SelectStatementContext +} + +func NewWithLateralStatementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *WithLateralStatementContext { + var p = new(WithLateralStatementContext) + + InitEmptySelectStatementContext(&p.SelectStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SelectStatementContext)) + + return p +} + +func (s *WithLateralStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *WithLateralStatementContext) QuerySpecificationNointo() IQuerySpecificationNointoContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuerySpecificationNointoContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuerySpecificationNointoContext) +} + +func (s *WithLateralStatementContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *WithLateralStatementContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *WithLateralStatementContext) AllLateralStatement() []ILateralStatementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILateralStatementContext); ok { + len++ + } + } + + tst := make([]ILateralStatementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILateralStatementContext); ok { + tst[i] = t.(ILateralStatementContext) + i++ + } + } + + return tst +} + +func (s *WithLateralStatementContext) LateralStatement(i int) ILateralStatementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILateralStatementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILateralStatementContext) +} + +func (s *WithLateralStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterWithLateralStatement(s) + } +} + +func (s *WithLateralStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitWithLateralStatement(s) + } +} + +func (p *MySqlParser) SelectStatement() (localctx ISelectStatementContext) { + localctx = NewSelectStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 200, MySqlParserRULE_selectStatement) + var _la int + + var _alt int + + p.SetState(3476) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 476, p.GetParserRuleContext()) { + case 1: + localctx = NewSimpleSelectContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3411) + p.QuerySpecification() + } + p.SetState(3413) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 459, p.GetParserRuleContext()) == 1 { + { + p.SetState(3412) + p.LockClause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + localctx = NewParenthesisSelectContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3415) + p.QueryExpression() + } + p.SetState(3417) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 460, p.GetParserRuleContext()) == 1 { + { + p.SetState(3416) + p.LockClause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 3: + localctx = NewUnionSelectContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + p.SetState(3421) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserSELECT: + { + p.SetState(3419) + p.QuerySpecificationNointo() + } + + case MySqlParserLR_BRACKET: + { + p.SetState(3420) + p.QueryExpressionNointo() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(3424) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(3423) + p.UnionStatement() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(3426) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 462, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(3436) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserUNION { + { + p.SetState(3428) + p.Match(MySqlParserUNION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3430) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserALL || _la == MySqlParserDISTINCT { + { + p.SetState(3429) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*UnionSelectContext).unionType = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserALL || _la == MySqlParserDISTINCT) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*UnionSelectContext).unionType = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(3434) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserSELECT: + { + p.SetState(3432) + p.QuerySpecification() + } + + case MySqlParserLR_BRACKET: + { + p.SetState(3433) + p.QueryExpression() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(3439) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 466, p.GetParserRuleContext()) == 1 { + { + p.SetState(3438) + p.OrderByClause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3442) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserLIMIT { + { + p.SetState(3441) + p.LimitClause() + } + + } + p.SetState(3445) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 468, p.GetParserRuleContext()) == 1 { + { + p.SetState(3444) + p.LockClause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 4: + localctx = NewUnionParenthesisSelectContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3447) + p.QueryExpressionNointo() + } + p.SetState(3449) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(3448) + p.UnionParenthesis() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(3451) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 469, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(3458) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserUNION { + { + p.SetState(3453) + p.Match(MySqlParserUNION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3455) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserALL || _la == MySqlParserDISTINCT { + { + p.SetState(3454) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*UnionParenthesisSelectContext).unionType = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserALL || _la == MySqlParserDISTINCT) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*UnionParenthesisSelectContext).unionType = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(3457) + p.QueryExpression() + } + + } + p.SetState(3461) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 472, p.GetParserRuleContext()) == 1 { + { + p.SetState(3460) + p.OrderByClause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3464) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserLIMIT { + { + p.SetState(3463) + p.LimitClause() + } + + } + p.SetState(3467) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 474, p.GetParserRuleContext()) == 1 { + { + p.SetState(3466) + p.LockClause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 5: + localctx = NewWithLateralStatementContext(p, localctx) + p.EnterOuterAlt(localctx, 5) + { + p.SetState(3469) + p.QuerySpecificationNointo() + } + p.SetState(3472) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == MySqlParserCOMMA { + { + p.SetState(3470) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3471) + p.LateralStatement() + } + + p.SetState(3474) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUpdateStatementContext is an interface to support dynamic dispatch. +type IUpdateStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SingleUpdateStatement() ISingleUpdateStatementContext + MultipleUpdateStatement() IMultipleUpdateStatementContext + + // IsUpdateStatementContext differentiates from other interfaces. + IsUpdateStatementContext() +} + +type UpdateStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUpdateStatementContext() *UpdateStatementContext { + var p = new(UpdateStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_updateStatement + return p +} + +func InitEmptyUpdateStatementContext(p *UpdateStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_updateStatement +} + +func (*UpdateStatementContext) IsUpdateStatementContext() {} + +func NewUpdateStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UpdateStatementContext { + var p = new(UpdateStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_updateStatement + + return p +} + +func (s *UpdateStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *UpdateStatementContext) SingleUpdateStatement() ISingleUpdateStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISingleUpdateStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISingleUpdateStatementContext) +} + +func (s *UpdateStatementContext) MultipleUpdateStatement() IMultipleUpdateStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipleUpdateStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipleUpdateStatementContext) +} + +func (s *UpdateStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UpdateStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *UpdateStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterUpdateStatement(s) + } +} + +func (s *UpdateStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitUpdateStatement(s) + } +} + +func (p *MySqlParser) UpdateStatement() (localctx IUpdateStatementContext) { + localctx = NewUpdateStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 202, MySqlParserRULE_updateStatement) + p.SetState(3480) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 477, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3478) + p.SingleUpdateStatement() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3479) + p.MultipleUpdateStatement() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IValuesStatementContext is an interface to support dynamic dispatch. +type IValuesStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + VALUES() antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + AllExpressionsWithDefaults() []IExpressionsWithDefaultsContext + ExpressionsWithDefaults(i int) IExpressionsWithDefaultsContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsValuesStatementContext differentiates from other interfaces. + IsValuesStatementContext() +} + +type ValuesStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyValuesStatementContext() *ValuesStatementContext { + var p = new(ValuesStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_valuesStatement + return p +} + +func InitEmptyValuesStatementContext(p *ValuesStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_valuesStatement +} + +func (*ValuesStatementContext) IsValuesStatementContext() {} + +func NewValuesStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ValuesStatementContext { + var p = new(ValuesStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_valuesStatement + + return p +} + +func (s *ValuesStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *ValuesStatementContext) VALUES() antlr.TerminalNode { + return s.GetToken(MySqlParserVALUES, 0) +} + +func (s *ValuesStatementContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(MySqlParserLR_BRACKET) +} + +func (s *ValuesStatementContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, i) +} + +func (s *ValuesStatementContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(MySqlParserRR_BRACKET) +} + +func (s *ValuesStatementContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, i) +} + +func (s *ValuesStatementContext) AllExpressionsWithDefaults() []IExpressionsWithDefaultsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionsWithDefaultsContext); ok { + len++ + } + } + + tst := make([]IExpressionsWithDefaultsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionsWithDefaultsContext); ok { + tst[i] = t.(IExpressionsWithDefaultsContext) + i++ + } + } + + return tst +} + +func (s *ValuesStatementContext) ExpressionsWithDefaults(i int) IExpressionsWithDefaultsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionsWithDefaultsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionsWithDefaultsContext) +} + +func (s *ValuesStatementContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *ValuesStatementContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *ValuesStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ValuesStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ValuesStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterValuesStatement(s) + } +} + +func (s *ValuesStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitValuesStatement(s) + } +} + +func (p *MySqlParser) ValuesStatement() (localctx IValuesStatementContext) { + localctx = NewValuesStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 204, MySqlParserRULE_valuesStatement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3482) + p.Match(MySqlParserVALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3483) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3485) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 478, p.GetParserRuleContext()) == 1 { + { + p.SetState(3484) + p.ExpressionsWithDefaults() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3487) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3496) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(3488) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3489) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3491) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 479, p.GetParserRuleContext()) == 1 { + { + p.SetState(3490) + p.ExpressionsWithDefaults() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3493) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(3498) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInsertStatementValueContext is an interface to support dynamic dispatch. +type IInsertStatementValueContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetInsertFormat returns the insertFormat token. + GetInsertFormat() antlr.Token + + // SetInsertFormat sets the insertFormat token. + SetInsertFormat(antlr.Token) + + // Getter signatures + SelectStatement() ISelectStatementContext + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + VALUES() antlr.TerminalNode + VALUE() antlr.TerminalNode + AllExpressionsWithDefaults() []IExpressionsWithDefaultsContext + ExpressionsWithDefaults(i int) IExpressionsWithDefaultsContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsInsertStatementValueContext differentiates from other interfaces. + IsInsertStatementValueContext() +} + +type InsertStatementValueContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + insertFormat antlr.Token +} + +func NewEmptyInsertStatementValueContext() *InsertStatementValueContext { + var p = new(InsertStatementValueContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_insertStatementValue + return p +} + +func InitEmptyInsertStatementValueContext(p *InsertStatementValueContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_insertStatementValue +} + +func (*InsertStatementValueContext) IsInsertStatementValueContext() {} + +func NewInsertStatementValueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InsertStatementValueContext { + var p = new(InsertStatementValueContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_insertStatementValue + + return p +} + +func (s *InsertStatementValueContext) GetParser() antlr.Parser { return s.parser } + +func (s *InsertStatementValueContext) GetInsertFormat() antlr.Token { return s.insertFormat } + +func (s *InsertStatementValueContext) SetInsertFormat(v antlr.Token) { s.insertFormat = v } + +func (s *InsertStatementValueContext) SelectStatement() ISelectStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelectStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelectStatementContext) +} + +func (s *InsertStatementValueContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(MySqlParserLR_BRACKET) +} + +func (s *InsertStatementValueContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, i) +} + +func (s *InsertStatementValueContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(MySqlParserRR_BRACKET) +} + +func (s *InsertStatementValueContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, i) +} + +func (s *InsertStatementValueContext) VALUES() antlr.TerminalNode { + return s.GetToken(MySqlParserVALUES, 0) +} + +func (s *InsertStatementValueContext) VALUE() antlr.TerminalNode { + return s.GetToken(MySqlParserVALUE, 0) +} + +func (s *InsertStatementValueContext) AllExpressionsWithDefaults() []IExpressionsWithDefaultsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionsWithDefaultsContext); ok { + len++ + } + } + + tst := make([]IExpressionsWithDefaultsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionsWithDefaultsContext); ok { + tst[i] = t.(IExpressionsWithDefaultsContext) + i++ + } + } + + return tst +} + +func (s *InsertStatementValueContext) ExpressionsWithDefaults(i int) IExpressionsWithDefaultsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionsWithDefaultsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionsWithDefaultsContext) +} + +func (s *InsertStatementValueContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *InsertStatementValueContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *InsertStatementValueContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *InsertStatementValueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *InsertStatementValueContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterInsertStatementValue(s) + } +} + +func (s *InsertStatementValueContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitInsertStatementValue(s) + } +} + +func (p *MySqlParser) InsertStatementValue() (localctx IInsertStatementValueContext) { + localctx = NewInsertStatementValueContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 206, MySqlParserRULE_insertStatementValue) + var _la int + + p.SetState(3517) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserSELECT, MySqlParserLR_BRACKET: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3499) + p.SelectStatement() + } + + case MySqlParserVALUES, MySqlParserVALUE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3500) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*InsertStatementValueContext).insertFormat = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserVALUES || _la == MySqlParserVALUE) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*InsertStatementValueContext).insertFormat = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(3501) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3503) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 481, p.GetParserRuleContext()) == 1 { + { + p.SetState(3502) + p.ExpressionsWithDefaults() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3505) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3514) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(3506) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3507) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3509) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 482, p.GetParserRuleContext()) == 1 { + { + p.SetState(3508) + p.ExpressionsWithDefaults() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3511) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(3516) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUpdatedElementContext is an interface to support dynamic dispatch. +type IUpdatedElementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FullColumnName() IFullColumnNameContext + EQUAL_SYMBOL() antlr.TerminalNode + Expression() IExpressionContext + DEFAULT() antlr.TerminalNode + + // IsUpdatedElementContext differentiates from other interfaces. + IsUpdatedElementContext() +} + +type UpdatedElementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUpdatedElementContext() *UpdatedElementContext { + var p = new(UpdatedElementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_updatedElement + return p +} + +func InitEmptyUpdatedElementContext(p *UpdatedElementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_updatedElement +} + +func (*UpdatedElementContext) IsUpdatedElementContext() {} + +func NewUpdatedElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UpdatedElementContext { + var p = new(UpdatedElementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_updatedElement + + return p +} + +func (s *UpdatedElementContext) GetParser() antlr.Parser { return s.parser } + +func (s *UpdatedElementContext) FullColumnName() IFullColumnNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFullColumnNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFullColumnNameContext) +} + +func (s *UpdatedElementContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *UpdatedElementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *UpdatedElementContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(MySqlParserDEFAULT, 0) +} + +func (s *UpdatedElementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UpdatedElementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *UpdatedElementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterUpdatedElement(s) + } +} + +func (s *UpdatedElementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitUpdatedElement(s) + } +} + +func (p *MySqlParser) UpdatedElement() (localctx IUpdatedElementContext) { + localctx = NewUpdatedElementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 208, MySqlParserRULE_updatedElement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3519) + p.FullColumnName() + } + { + p.SetState(3520) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3523) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 485, p.GetParserRuleContext()) { + case 1: + { + p.SetState(3521) + p.expression(0) + } + + case 2: + { + p.SetState(3522) + p.Match(MySqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAssignmentFieldContext is an interface to support dynamic dispatch. +type IAssignmentFieldContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Uid() IUidContext + LOCAL_ID() antlr.TerminalNode + + // IsAssignmentFieldContext differentiates from other interfaces. + IsAssignmentFieldContext() +} + +type AssignmentFieldContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAssignmentFieldContext() *AssignmentFieldContext { + var p = new(AssignmentFieldContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_assignmentField + return p +} + +func InitEmptyAssignmentFieldContext(p *AssignmentFieldContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_assignmentField +} + +func (*AssignmentFieldContext) IsAssignmentFieldContext() {} + +func NewAssignmentFieldContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AssignmentFieldContext { + var p = new(AssignmentFieldContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_assignmentField + + return p +} + +func (s *AssignmentFieldContext) GetParser() antlr.Parser { return s.parser } + +func (s *AssignmentFieldContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *AssignmentFieldContext) LOCAL_ID() antlr.TerminalNode { + return s.GetToken(MySqlParserLOCAL_ID, 0) +} + +func (s *AssignmentFieldContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AssignmentFieldContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AssignmentFieldContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAssignmentField(s) + } +} + +func (s *AssignmentFieldContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAssignmentField(s) + } +} + +func (p *MySqlParser) AssignmentField() (localctx IAssignmentFieldContext) { + localctx = NewAssignmentFieldContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 210, MySqlParserRULE_assignmentField) + p.SetState(3527) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserARRAY, MySqlParserATTRIBUTE, MySqlParserBUCKETS, MySqlParserCONDITION, MySqlParserCURRENT, MySqlParserCURRENT_USER, MySqlParserDATABASE, MySqlParserDEFAULT, MySqlParserDIAGNOSTICS, MySqlParserEMPTY, MySqlParserENFORCED, MySqlParserEXCEPT, MySqlParserGROUP, MySqlParserIF, MySqlParserIGNORED, MySqlParserINSERT, MySqlParserLATERAL, MySqlParserLEFT, MySqlParserNUMBER, MySqlParserOPTIONAL, MySqlParserORDER, MySqlParserPRIMARY, MySqlParserREPEAT, MySqlParserREPLACE, MySqlParserRIGHT, MySqlParserSCHEMA, MySqlParserSKIP_QUERY_REWRITE, MySqlParserSTACKED, MySqlParserSTATEMENT, MySqlParserDATE, MySqlParserTIME, MySqlParserTIMESTAMP, MySqlParserDATETIME, MySqlParserYEAR, MySqlParserBINARY, MySqlParserTEXT, MySqlParserENUM, MySqlParserSERIAL, MySqlParserJSON_ARRAY, MySqlParserJSON_ARRAYAGG, MySqlParserJSON_ARRAY_APPEND, MySqlParserJSON_ARRAY_INSERT, MySqlParserJSON_CONTAINS, MySqlParserJSON_CONTAINS_PATH, MySqlParserJSON_DEPTH, MySqlParserJSON_EXTRACT, MySqlParserJSON_INSERT, MySqlParserJSON_KEYS, MySqlParserJSON_LENGTH, MySqlParserJSON_MERGE, MySqlParserJSON_MERGE_PATCH, MySqlParserJSON_MERGE_PRESERVE, MySqlParserJSON_OBJECT, MySqlParserJSON_OBJECTAGG, MySqlParserJSON_OVERLAPS, MySqlParserJSON_PRETTY, MySqlParserJSON_QUOTE, MySqlParserJSON_REMOVE, MySqlParserJSON_REPLACE, MySqlParserJSON_SCHEMA_VALID, MySqlParserJSON_SCHEMA_VALIDATION_REPORT, MySqlParserJSON_SEARCH, MySqlParserJSON_SET, MySqlParserJSON_STORAGE_FREE, MySqlParserJSON_STORAGE_SIZE, MySqlParserJSON_TABLE, MySqlParserJSON_TYPE, MySqlParserJSON_UNQUOTE, MySqlParserJSON_VALID, MySqlParserJSON_VALUE, MySqlParserNESTED, MySqlParserORDINALITY, MySqlParserPATH, MySqlParserAVG, MySqlParserBIT_AND, MySqlParserBIT_OR, MySqlParserBIT_XOR, MySqlParserCOUNT, MySqlParserCUME_DIST, MySqlParserDENSE_RANK, MySqlParserFIRST_VALUE, MySqlParserGROUP_CONCAT, MySqlParserLAG, MySqlParserLAST_VALUE, MySqlParserLEAD, MySqlParserMAX, MySqlParserMIN, MySqlParserNTILE, MySqlParserNTH_VALUE, MySqlParserPERCENT_RANK, MySqlParserRANK, MySqlParserROW_NUMBER, MySqlParserSTD, MySqlParserSTDDEV, MySqlParserSTDDEV_POP, MySqlParserSTDDEV_SAMP, MySqlParserSUM, MySqlParserVAR_POP, MySqlParserVAR_SAMP, MySqlParserVARIANCE, MySqlParserCURRENT_DATE, MySqlParserCURRENT_TIME, MySqlParserCURRENT_TIMESTAMP, MySqlParserLOCALTIME, MySqlParserCURDATE, MySqlParserCURTIME, MySqlParserDATE_ADD, MySqlParserDATE_SUB, MySqlParserLOCALTIMESTAMP, MySqlParserNOW, MySqlParserPOSITION, MySqlParserSUBSTR, MySqlParserSUBSTRING, MySqlParserSYSDATE, MySqlParserTRIM, MySqlParserUTC_DATE, MySqlParserUTC_TIME, MySqlParserUTC_TIMESTAMP, MySqlParserACCOUNT, MySqlParserACTION, MySqlParserAFTER, MySqlParserAGGREGATE, MySqlParserALGORITHM, MySqlParserANY, MySqlParserAT, MySqlParserAUTHORS, MySqlParserAUTOCOMMIT, MySqlParserAUTOEXTEND_SIZE, MySqlParserAUTO_INCREMENT, MySqlParserAVG_ROW_LENGTH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserBIT, MySqlParserBLOCK, MySqlParserBOOL, MySqlParserBOOLEAN, MySqlParserBTREE, MySqlParserCACHE, MySqlParserCASCADED, MySqlParserCHAIN, MySqlParserCHANGED, MySqlParserCHANNEL, MySqlParserCHECKSUM, MySqlParserPAGE_CHECKSUM, MySqlParserCIPHER, MySqlParserCLASS_ORIGIN, MySqlParserCLIENT, MySqlParserCLOSE, MySqlParserCLUSTERING, MySqlParserCOALESCE, MySqlParserCODE, MySqlParserCOLUMNS, MySqlParserCOLUMN_FORMAT, MySqlParserCOLUMN_NAME, MySqlParserCOMMENT, MySqlParserCOMMIT, MySqlParserCOMPACT, MySqlParserCOMPLETION, MySqlParserCOMPRESSED, MySqlParserCOMPRESSION, MySqlParserCONCURRENT, MySqlParserCONNECT, MySqlParserCONNECTION, MySqlParserCONSISTENT, MySqlParserCONSTRAINT_CATALOG, MySqlParserCONSTRAINT_SCHEMA, MySqlParserCONSTRAINT_NAME, MySqlParserCONTAINS, MySqlParserCONTEXT, MySqlParserCONTRIBUTORS, MySqlParserCOPY, MySqlParserCPU, MySqlParserCURSOR_NAME, MySqlParserDATA, MySqlParserDATAFILE, MySqlParserDEALLOCATE, MySqlParserDEFAULT_AUTH, MySqlParserDEFINER, MySqlParserDELAY_KEY_WRITE, MySqlParserDES_KEY_FILE, MySqlParserDIRECTORY, MySqlParserDISABLE, MySqlParserDISCARD, MySqlParserDISK, MySqlParserDO, MySqlParserDUMPFILE, MySqlParserDUPLICATE, MySqlParserDYNAMIC, MySqlParserENABLE, MySqlParserENCRYPTION, MySqlParserEND, MySqlParserENDS, MySqlParserENGINE, MySqlParserENGINES, MySqlParserERROR, MySqlParserERRORS, MySqlParserESCAPE, MySqlParserEVEN, MySqlParserEVENT, MySqlParserEVENTS, MySqlParserEVERY, MySqlParserEXCHANGE, MySqlParserEXCLUSIVE, MySqlParserEXPIRE, MySqlParserEXPORT, MySqlParserEXTENDED, MySqlParserEXTENT_SIZE, MySqlParserFAILED_LOGIN_ATTEMPTS, MySqlParserFAST, MySqlParserFAULTS, MySqlParserFIELDS, MySqlParserFILE_BLOCK_SIZE, MySqlParserFILTER, MySqlParserFIRST, MySqlParserFIXED, MySqlParserFLUSH, MySqlParserFOLLOWS, MySqlParserFOUND, MySqlParserFULL, MySqlParserFUNCTION, MySqlParserGENERAL, MySqlParserGLOBAL, MySqlParserGRANTS, MySqlParserGROUP_REPLICATION, MySqlParserHANDLER, MySqlParserHASH, MySqlParserHELP, MySqlParserHISTORY, MySqlParserHOST, MySqlParserHOSTS, MySqlParserIDENTIFIED, MySqlParserIGNORE_SERVER_IDS, MySqlParserIMPORT, MySqlParserINDEXES, MySqlParserINITIAL_SIZE, MySqlParserINPLACE, MySqlParserINSERT_METHOD, MySqlParserINSTALL, MySqlParserINSTANCE, MySqlParserINSTANT, MySqlParserINVISIBLE, MySqlParserINVOKER, MySqlParserIO, MySqlParserIO_THREAD, MySqlParserIPC, MySqlParserISOLATION, MySqlParserISSUER, MySqlParserJSON, MySqlParserKEY_BLOCK_SIZE, MySqlParserLANGUAGE, MySqlParserLAST, MySqlParserLEAVES, MySqlParserLESS, MySqlParserLEVEL, MySqlParserLIST, MySqlParserLOCAL, MySqlParserLOGFILE, MySqlParserLOGS, MySqlParserMASTER, MySqlParserMASTER_AUTO_POSITION, MySqlParserMASTER_CONNECT_RETRY, MySqlParserMASTER_DELAY, MySqlParserMASTER_HEARTBEAT_PERIOD, MySqlParserMASTER_HOST, MySqlParserMASTER_LOG_FILE, MySqlParserMASTER_LOG_POS, MySqlParserMASTER_PASSWORD, MySqlParserMASTER_PORT, MySqlParserMASTER_RETRY_COUNT, MySqlParserMASTER_SSL, MySqlParserMASTER_SSL_CA, MySqlParserMASTER_SSL_CAPATH, MySqlParserMASTER_SSL_CERT, MySqlParserMASTER_SSL_CIPHER, MySqlParserMASTER_SSL_CRL, MySqlParserMASTER_SSL_CRLPATH, MySqlParserMASTER_SSL_KEY, MySqlParserMASTER_TLS_VERSION, MySqlParserMASTER_USER, MySqlParserMAX_CONNECTIONS_PER_HOUR, MySqlParserMAX_QUERIES_PER_HOUR, MySqlParserMAX_ROWS, MySqlParserMAX_SIZE, MySqlParserMAX_UPDATES_PER_HOUR, MySqlParserMAX_USER_CONNECTIONS, MySqlParserMEDIUM, MySqlParserMEMBER, MySqlParserMERGE, MySqlParserMESSAGE_TEXT, MySqlParserMID, MySqlParserMIGRATE, MySqlParserMIN_ROWS, MySqlParserMODE, MySqlParserMODIFY, MySqlParserMUTEX, MySqlParserMYSQL, MySqlParserMYSQL_ERRNO, MySqlParserNAME, MySqlParserNAMES, MySqlParserNCHAR, MySqlParserNEVER, MySqlParserNEXT, MySqlParserNO, MySqlParserNOCOPY, MySqlParserNOWAIT, MySqlParserNODEGROUP, MySqlParserNONE, MySqlParserODBC, MySqlParserOFFLINE, MySqlParserOFFSET, MySqlParserOF, MySqlParserOJ, MySqlParserOLD_PASSWORD, MySqlParserONE, MySqlParserONLINE, MySqlParserONLY, MySqlParserOPEN, MySqlParserOPTIMIZER_COSTS, MySqlParserOPTIONS, MySqlParserOWNER, MySqlParserPACK_KEYS, MySqlParserPAGE, MySqlParserPARSER, MySqlParserPARTIAL, MySqlParserPARTITIONING, MySqlParserPARTITIONS, MySqlParserPASSWORD, MySqlParserPASSWORD_LOCK_TIME, MySqlParserPHASE, MySqlParserPLUGIN, MySqlParserPLUGIN_DIR, MySqlParserPLUGINS, MySqlParserPORT, MySqlParserPRECEDES, MySqlParserPREPARE, MySqlParserPRESERVE, MySqlParserPREV, MySqlParserPROCESSLIST, MySqlParserPROFILE, MySqlParserPROFILES, MySqlParserPROXY, MySqlParserQUERY, MySqlParserQUICK, MySqlParserREBUILD, MySqlParserRECOVER, MySqlParserRECURSIVE, MySqlParserREDO_BUFFER_SIZE, MySqlParserREDUNDANT, MySqlParserRELAY, MySqlParserRELAY_LOG_FILE, MySqlParserRELAY_LOG_POS, MySqlParserRELAYLOG, MySqlParserREMOVE, MySqlParserREORGANIZE, MySqlParserREPAIR, MySqlParserREPLICATE_DO_DB, MySqlParserREPLICATE_DO_TABLE, MySqlParserREPLICATE_IGNORE_DB, MySqlParserREPLICATE_IGNORE_TABLE, MySqlParserREPLICATE_REWRITE_DB, MySqlParserREPLICATE_WILD_DO_TABLE, MySqlParserREPLICATE_WILD_IGNORE_TABLE, MySqlParserREPLICATION, MySqlParserRESET, MySqlParserRESUME, MySqlParserRETURNED_SQLSTATE, MySqlParserRETURNING, MySqlParserRETURNS, MySqlParserREUSE, MySqlParserROLE, MySqlParserROLLBACK, MySqlParserROLLUP, MySqlParserROTATE, MySqlParserROW, MySqlParserROWS, MySqlParserROW_FORMAT, MySqlParserRTREE, MySqlParserSAVEPOINT, MySqlParserSCHEDULE, MySqlParserSECURITY, MySqlParserSERVER, MySqlParserSESSION, MySqlParserSHARE, MySqlParserSHARED, MySqlParserSIGNED, MySqlParserSIMPLE, MySqlParserSLAVE, MySqlParserSLOW, MySqlParserSNAPSHOT, MySqlParserSOCKET, MySqlParserSOME, MySqlParserSONAME, MySqlParserSOUNDS, MySqlParserSOURCE, MySqlParserSQL_AFTER_GTIDS, MySqlParserSQL_AFTER_MTS_GAPS, MySqlParserSQL_BEFORE_GTIDS, MySqlParserSQL_BUFFER_RESULT, MySqlParserSQL_CACHE, MySqlParserSQL_NO_CACHE, MySqlParserSQL_THREAD, MySqlParserSTART, MySqlParserSTARTS, MySqlParserSTATS_AUTO_RECALC, MySqlParserSTATS_PERSISTENT, MySqlParserSTATS_SAMPLE_PAGES, MySqlParserSTATUS, MySqlParserSTOP, MySqlParserSTORAGE, MySqlParserSTRING, MySqlParserSUBCLASS_ORIGIN, MySqlParserSUBJECT, MySqlParserSUBPARTITION, MySqlParserSUBPARTITIONS, MySqlParserSUSPEND, MySqlParserSWAPS, MySqlParserSWITCHES, MySqlParserTABLE_NAME, MySqlParserTABLESPACE, MySqlParserTABLE_TYPE, MySqlParserTEMPORARY, MySqlParserTEMPTABLE, MySqlParserTHAN, MySqlParserTRADITIONAL, MySqlParserTRANSACTION, MySqlParserTRANSACTIONAL, MySqlParserTRIGGERS, MySqlParserTRUNCATE, MySqlParserUNBOUNDED, MySqlParserUNDEFINED, MySqlParserUNDOFILE, MySqlParserUNDO_BUFFER_SIZE, MySqlParserUNINSTALL, MySqlParserUNKNOWN, MySqlParserUNTIL, MySqlParserUPGRADE, MySqlParserUSER, MySqlParserUSE_FRM, MySqlParserUSER_RESOURCES, MySqlParserVALIDATION, MySqlParserVALUE, MySqlParserVARIABLES, MySqlParserVIEW, MySqlParserVIRTUAL, MySqlParserVISIBLE, MySqlParserWAIT, MySqlParserWARNINGS, MySqlParserWITHOUT, MySqlParserWORK, MySqlParserWRAPPER, MySqlParserX509, MySqlParserXA, MySqlParserXML, MySqlParserYES, MySqlParserEUR, MySqlParserUSA, MySqlParserJIS, MySqlParserISO, MySqlParserINTERNAL, MySqlParserQUARTER, MySqlParserMONTH, MySqlParserDAY, MySqlParserHOUR, MySqlParserMINUTE, MySqlParserWEEK, MySqlParserSECOND, MySqlParserMICROSECOND, MySqlParserADMIN, MySqlParserAUDIT_ABORT_EXEMPT, MySqlParserAUDIT_ADMIN, MySqlParserAUTHENTICATION_POLICY_ADMIN, MySqlParserBACKUP_ADMIN, MySqlParserBINLOG_ADMIN, MySqlParserBINLOG_ENCRYPTION_ADMIN, MySqlParserCLONE_ADMIN, MySqlParserCONNECTION_ADMIN, MySqlParserENCRYPTION_KEY_ADMIN, MySqlParserEXECUTE, MySqlParserFILE, MySqlParserFIREWALL_ADMIN, MySqlParserFIREWALL_EXEMPT, MySqlParserFIREWALL_USER, MySqlParserGROUP_REPLICATION_ADMIN, MySqlParserINNODB_REDO_LOG_ARCHIVE, MySqlParserINVOKE, MySqlParserLAMBDA, MySqlParserNDB_STORED_USER, MySqlParserPASSWORDLESS_USER_ADMIN, MySqlParserPERSIST_RO_VARIABLES_ADMIN, MySqlParserPRIVILEGES, MySqlParserPROCESS, MySqlParserRELOAD, MySqlParserREPLICATION_APPLIER, MySqlParserREPLICATION_SLAVE_ADMIN, MySqlParserRESOURCE_GROUP_ADMIN, MySqlParserRESOURCE_GROUP_USER, MySqlParserROLE_ADMIN, MySqlParserROUTINE, MySqlParserS3, MySqlParserSESSION_VARIABLES_ADMIN, MySqlParserSET_USER_ID, MySqlParserSHOW_ROUTINE, MySqlParserSHUTDOWN, MySqlParserSUPER, MySqlParserSYSTEM_VARIABLES_ADMIN, MySqlParserTABLES, MySqlParserTABLE_ENCRYPTION_ADMIN, MySqlParserVERSION_TOKEN_ADMIN, MySqlParserXA_RECOVER_ADMIN, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserARCHIVE, MySqlParserBLACKHOLE, MySqlParserCSV, MySqlParserFEDERATED, MySqlParserINNODB, MySqlParserMEMORY, MySqlParserMRG_MYISAM, MySqlParserMYISAM, MySqlParserNDB, MySqlParserNDBCLUSTER, MySqlParserPERFORMANCE_SCHEMA, MySqlParserTOKUDB, MySqlParserREPEATABLE, MySqlParserCOMMITTED, MySqlParserUNCOMMITTED, MySqlParserSERIALIZABLE, MySqlParserGEOMETRYCOLLECTION, MySqlParserLINESTRING, MySqlParserMULTILINESTRING, MySqlParserMULTIPOINT, MySqlParserMULTIPOLYGON, MySqlParserPOINT, MySqlParserPOLYGON, MySqlParserABS, MySqlParserACOS, MySqlParserADDDATE, MySqlParserADDTIME, MySqlParserAES_DECRYPT, MySqlParserAES_ENCRYPT, MySqlParserAREA, MySqlParserASBINARY, MySqlParserASIN, MySqlParserASTEXT, MySqlParserASWKB, MySqlParserASWKT, MySqlParserASYMMETRIC_DECRYPT, MySqlParserASYMMETRIC_DERIVE, MySqlParserASYMMETRIC_ENCRYPT, MySqlParserASYMMETRIC_SIGN, MySqlParserASYMMETRIC_VERIFY, MySqlParserATAN, MySqlParserATAN2, MySqlParserBENCHMARK, MySqlParserBIN, MySqlParserBIT_COUNT, MySqlParserBIT_LENGTH, MySqlParserBUFFER, MySqlParserCATALOG_NAME, MySqlParserCEIL, MySqlParserCEILING, MySqlParserCENTROID, MySqlParserCHARACTER_LENGTH, MySqlParserCHARSET, MySqlParserCHAR_LENGTH, MySqlParserCOERCIBILITY, MySqlParserCOLLATION, MySqlParserCOMPRESS, MySqlParserCONCAT, MySqlParserCONCAT_WS, MySqlParserCONNECTION_ID, MySqlParserCONV, MySqlParserCONVERT_TZ, MySqlParserCOS, MySqlParserCOT, MySqlParserCRC32, MySqlParserCREATE_ASYMMETRIC_PRIV_KEY, MySqlParserCREATE_ASYMMETRIC_PUB_KEY, MySqlParserCREATE_DH_PARAMETERS, MySqlParserCREATE_DIGEST, MySqlParserCROSSES, MySqlParserDATEDIFF, MySqlParserDATE_FORMAT, MySqlParserDAYNAME, MySqlParserDAYOFMONTH, MySqlParserDAYOFWEEK, MySqlParserDAYOFYEAR, MySqlParserDECODE, MySqlParserDEGREES, MySqlParserDES_DECRYPT, MySqlParserDES_ENCRYPT, MySqlParserDIMENSION, MySqlParserDISJOINT, MySqlParserDISTANCE, MySqlParserELT, MySqlParserENCODE, MySqlParserENCRYPT, MySqlParserENDPOINT, MySqlParserENGINE_ATTRIBUTE, MySqlParserENVELOPE, MySqlParserEQUALS, MySqlParserEXP, MySqlParserEXPORT_SET, MySqlParserEXTERIORRING, MySqlParserEXTRACTVALUE, MySqlParserFIELD, MySqlParserFIND_IN_SET, MySqlParserFLOOR, MySqlParserFORMAT, MySqlParserFOUND_ROWS, MySqlParserFROM_BASE64, MySqlParserFROM_DAYS, MySqlParserFROM_UNIXTIME, MySqlParserGEOMCOLLFROMTEXT, MySqlParserGEOMCOLLFROMWKB, MySqlParserGEOMETRYCOLLECTIONFROMTEXT, MySqlParserGEOMETRYCOLLECTIONFROMWKB, MySqlParserGEOMETRYFROMTEXT, MySqlParserGEOMETRYFROMWKB, MySqlParserGEOMETRYN, MySqlParserGEOMETRYTYPE, MySqlParserGEOMFROMTEXT, MySqlParserGEOMFROMWKB, MySqlParserGET_FORMAT, MySqlParserGET_LOCK, MySqlParserGLENGTH, MySqlParserGREATEST, MySqlParserGTID_SUBSET, MySqlParserGTID_SUBTRACT, MySqlParserHEX, MySqlParserIFNULL, MySqlParserINET6_ATON, MySqlParserINET6_NTOA, MySqlParserINET_ATON, MySqlParserINET_NTOA, MySqlParserINSTR, MySqlParserINTERIORRINGN, MySqlParserINTERSECTS, MySqlParserISCLOSED, MySqlParserISEMPTY, MySqlParserISNULL, MySqlParserISSIMPLE, MySqlParserIS_FREE_LOCK, MySqlParserIS_IPV4, MySqlParserIS_IPV4_COMPAT, MySqlParserIS_IPV4_MAPPED, MySqlParserIS_IPV6, MySqlParserIS_USED_LOCK, MySqlParserLAST_INSERT_ID, MySqlParserLCASE, MySqlParserLEAST, MySqlParserLENGTH, MySqlParserLINEFROMTEXT, MySqlParserLINEFROMWKB, MySqlParserLINESTRINGFROMTEXT, MySqlParserLINESTRINGFROMWKB, MySqlParserLN, MySqlParserLOAD_FILE, MySqlParserLOCATE, MySqlParserLOG, MySqlParserLOG10, MySqlParserLOG2, MySqlParserLOWER, MySqlParserLPAD, MySqlParserLTRIM, MySqlParserMAKEDATE, MySqlParserMAKETIME, MySqlParserMAKE_SET, MySqlParserMASTER_POS_WAIT, MySqlParserMBRCONTAINS, MySqlParserMBRDISJOINT, MySqlParserMBREQUAL, MySqlParserMBRINTERSECTS, MySqlParserMBROVERLAPS, MySqlParserMBRTOUCHES, MySqlParserMBRWITHIN, MySqlParserMD5, MySqlParserMLINEFROMTEXT, MySqlParserMLINEFROMWKB, MySqlParserMONTHNAME, MySqlParserMPOINTFROMTEXT, MySqlParserMPOINTFROMWKB, MySqlParserMPOLYFROMTEXT, MySqlParserMPOLYFROMWKB, MySqlParserMULTILINESTRINGFROMTEXT, MySqlParserMULTILINESTRINGFROMWKB, MySqlParserMULTIPOINTFROMTEXT, MySqlParserMULTIPOINTFROMWKB, MySqlParserMULTIPOLYGONFROMTEXT, MySqlParserMULTIPOLYGONFROMWKB, MySqlParserNAME_CONST, MySqlParserNULLIF, MySqlParserNUMGEOMETRIES, MySqlParserNUMINTERIORRINGS, MySqlParserNUMPOINTS, MySqlParserOCT, MySqlParserOCTET_LENGTH, MySqlParserORD, MySqlParserOVERLAPS, MySqlParserPERIOD_ADD, MySqlParserPERIOD_DIFF, MySqlParserPI, MySqlParserPOINTFROMTEXT, MySqlParserPOINTFROMWKB, MySqlParserPOINTN, MySqlParserPOLYFROMTEXT, MySqlParserPOLYFROMWKB, MySqlParserPOLYGONFROMTEXT, MySqlParserPOLYGONFROMWKB, MySqlParserPOW, MySqlParserPOWER, MySqlParserQUOTE, MySqlParserRADIANS, MySqlParserRAND, MySqlParserRANDOM, MySqlParserRANDOM_BYTES, MySqlParserRELEASE_LOCK, MySqlParserREVERSE, MySqlParserROUND, MySqlParserROW_COUNT, MySqlParserRPAD, MySqlParserRTRIM, MySqlParserSEC_TO_TIME, MySqlParserSECONDARY_ENGINE_ATTRIBUTE, MySqlParserSESSION_USER, MySqlParserSHA, MySqlParserSHA1, MySqlParserSHA2, MySqlParserSCHEMA_NAME, MySqlParserSIGN, MySqlParserSIN, MySqlParserSLEEP, MySqlParserSOUNDEX, MySqlParserSQL_THREAD_WAIT_AFTER_GTIDS, MySqlParserSQRT, MySqlParserSRID, MySqlParserSTARTPOINT, MySqlParserSTRCMP, MySqlParserSTR_TO_DATE, MySqlParserST_AREA, MySqlParserST_ASBINARY, MySqlParserST_ASTEXT, MySqlParserST_ASWKB, MySqlParserST_ASWKT, MySqlParserST_BUFFER, MySqlParserST_CENTROID, MySqlParserST_CONTAINS, MySqlParserST_CROSSES, MySqlParserST_DIFFERENCE, MySqlParserST_DIMENSION, MySqlParserST_DISJOINT, MySqlParserST_DISTANCE, MySqlParserST_ENDPOINT, MySqlParserST_ENVELOPE, MySqlParserST_EQUALS, MySqlParserST_EXTERIORRING, MySqlParserST_GEOMCOLLFROMTEXT, MySqlParserST_GEOMCOLLFROMTXT, MySqlParserST_GEOMCOLLFROMWKB, MySqlParserST_GEOMETRYCOLLECTIONFROMTEXT, MySqlParserST_GEOMETRYCOLLECTIONFROMWKB, MySqlParserST_GEOMETRYFROMTEXT, MySqlParserST_GEOMETRYFROMWKB, MySqlParserST_GEOMETRYN, MySqlParserST_GEOMETRYTYPE, MySqlParserST_GEOMFROMTEXT, MySqlParserST_GEOMFROMWKB, MySqlParserST_INTERIORRINGN, MySqlParserST_INTERSECTION, MySqlParserST_INTERSECTS, MySqlParserST_ISCLOSED, MySqlParserST_ISEMPTY, MySqlParserST_ISSIMPLE, MySqlParserST_LINEFROMTEXT, MySqlParserST_LINEFROMWKB, MySqlParserST_LINESTRINGFROMTEXT, MySqlParserST_LINESTRINGFROMWKB, MySqlParserST_NUMGEOMETRIES, MySqlParserST_NUMINTERIORRING, MySqlParserST_NUMINTERIORRINGS, MySqlParserST_NUMPOINTS, MySqlParserST_OVERLAPS, MySqlParserST_POINTFROMTEXT, MySqlParserST_POINTFROMWKB, MySqlParserST_POINTN, MySqlParserST_POLYFROMTEXT, MySqlParserST_POLYFROMWKB, MySqlParserST_POLYGONFROMTEXT, MySqlParserST_POLYGONFROMWKB, MySqlParserST_SRID, MySqlParserST_STARTPOINT, MySqlParserST_SYMDIFFERENCE, MySqlParserST_TOUCHES, MySqlParserST_UNION, MySqlParserST_WITHIN, MySqlParserST_X, MySqlParserST_Y, MySqlParserSTRING_TO_VECTOR, MySqlParserSUBDATE, MySqlParserSUBSTRING_INDEX, MySqlParserSUBTIME, MySqlParserSYSTEM_USER, MySqlParserTAN, MySqlParserTIMEDIFF, MySqlParserTIMESTAMPADD, MySqlParserTIMESTAMPDIFF, MySqlParserTIME_FORMAT, MySqlParserTIME_TO_SEC, MySqlParserTOUCHES, MySqlParserTO_BASE64, MySqlParserTO_DAYS, MySqlParserTO_SECONDS, MySqlParserTP_CONNECTION_ADMIN, MySqlParserUCASE, MySqlParserUNCOMPRESS, MySqlParserUNCOMPRESSED_LENGTH, MySqlParserUNHEX, MySqlParserUNIX_TIMESTAMP, MySqlParserUPDATEXML, MySqlParserUPPER, MySqlParserUUID, MySqlParserUUID_SHORT, MySqlParserVALIDATE_PASSWORD_STRENGTH, MySqlParserVECTOR_DIM, MySqlParserVECTOR_TO_STRING, MySqlParserVERSION, MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS, MySqlParserWEEKDAY, MySqlParserWEEKOFYEAR, MySqlParserWEIGHT_STRING, MySqlParserWITHIN, MySqlParserYEARWEEK, MySqlParserY_FUNCTION, MySqlParserX_FUNCTION, MySqlParserMOD, MySqlParserCHARSET_REVERSE_QOUTE_STRING, MySqlParserSTRING_LITERAL, MySqlParserID: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3525) + p.Uid() + } + + case MySqlParserLOCAL_ID: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3526) + p.Match(MySqlParserLOCAL_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILockClauseContext is an interface to support dynamic dispatch. +type ILockClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FOR() antlr.TerminalNode + UPDATE() antlr.TerminalNode + LOCK() antlr.TerminalNode + IN() antlr.TerminalNode + SHARE() antlr.TerminalNode + MODE() antlr.TerminalNode + + // IsLockClauseContext differentiates from other interfaces. + IsLockClauseContext() +} + +type LockClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLockClauseContext() *LockClauseContext { + var p = new(LockClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_lockClause + return p +} + +func InitEmptyLockClauseContext(p *LockClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_lockClause +} + +func (*LockClauseContext) IsLockClauseContext() {} + +func NewLockClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LockClauseContext { + var p = new(LockClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_lockClause + + return p +} + +func (s *LockClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *LockClauseContext) FOR() antlr.TerminalNode { + return s.GetToken(MySqlParserFOR, 0) +} + +func (s *LockClauseContext) UPDATE() antlr.TerminalNode { + return s.GetToken(MySqlParserUPDATE, 0) +} + +func (s *LockClauseContext) LOCK() antlr.TerminalNode { + return s.GetToken(MySqlParserLOCK, 0) +} + +func (s *LockClauseContext) IN() antlr.TerminalNode { + return s.GetToken(MySqlParserIN, 0) +} + +func (s *LockClauseContext) SHARE() antlr.TerminalNode { + return s.GetToken(MySqlParserSHARE, 0) +} + +func (s *LockClauseContext) MODE() antlr.TerminalNode { + return s.GetToken(MySqlParserMODE, 0) +} + +func (s *LockClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LockClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *LockClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterLockClause(s) + } +} + +func (s *LockClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitLockClause(s) + } +} + +func (p *MySqlParser) LockClause() (localctx ILockClauseContext) { + localctx = NewLockClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 212, MySqlParserRULE_lockClause) + p.SetState(3535) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserFOR: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3529) + p.Match(MySqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3530) + p.Match(MySqlParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserLOCK: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3531) + p.Match(MySqlParserLOCK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3532) + p.Match(MySqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3533) + p.Match(MySqlParserSHARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3534) + p.Match(MySqlParserMODE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISingleDeleteStatementContext is an interface to support dynamic dispatch. +type ISingleDeleteStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPriority returns the priority token. + GetPriority() antlr.Token + + // SetPriority sets the priority token. + SetPriority(antlr.Token) + + // Getter signatures + DELETE() antlr.TerminalNode + FROM() antlr.TerminalNode + TableName() ITableNameContext + QUICK() antlr.TerminalNode + IGNORE() antlr.TerminalNode + Uid() IUidContext + PARTITION() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + UidList() IUidListContext + RR_BRACKET() antlr.TerminalNode + WHERE() antlr.TerminalNode + Expression() IExpressionContext + OrderByClause() IOrderByClauseContext + LIMIT() antlr.TerminalNode + LimitClauseAtom() ILimitClauseAtomContext + LOW_PRIORITY() antlr.TerminalNode + AS() antlr.TerminalNode + + // IsSingleDeleteStatementContext differentiates from other interfaces. + IsSingleDeleteStatementContext() +} + +type SingleDeleteStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + priority antlr.Token +} + +func NewEmptySingleDeleteStatementContext() *SingleDeleteStatementContext { + var p = new(SingleDeleteStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_singleDeleteStatement + return p +} + +func InitEmptySingleDeleteStatementContext(p *SingleDeleteStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_singleDeleteStatement +} + +func (*SingleDeleteStatementContext) IsSingleDeleteStatementContext() {} + +func NewSingleDeleteStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SingleDeleteStatementContext { + var p = new(SingleDeleteStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_singleDeleteStatement + + return p +} + +func (s *SingleDeleteStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *SingleDeleteStatementContext) GetPriority() antlr.Token { return s.priority } + +func (s *SingleDeleteStatementContext) SetPriority(v antlr.Token) { s.priority = v } + +func (s *SingleDeleteStatementContext) DELETE() antlr.TerminalNode { + return s.GetToken(MySqlParserDELETE, 0) +} + +func (s *SingleDeleteStatementContext) FROM() antlr.TerminalNode { + return s.GetToken(MySqlParserFROM, 0) +} + +func (s *SingleDeleteStatementContext) TableName() ITableNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableNameContext) +} + +func (s *SingleDeleteStatementContext) QUICK() antlr.TerminalNode { + return s.GetToken(MySqlParserQUICK, 0) +} + +func (s *SingleDeleteStatementContext) IGNORE() antlr.TerminalNode { + return s.GetToken(MySqlParserIGNORE, 0) +} + +func (s *SingleDeleteStatementContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *SingleDeleteStatementContext) PARTITION() antlr.TerminalNode { + return s.GetToken(MySqlParserPARTITION, 0) +} + +func (s *SingleDeleteStatementContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *SingleDeleteStatementContext) UidList() IUidListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidListContext) +} + +func (s *SingleDeleteStatementContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *SingleDeleteStatementContext) WHERE() antlr.TerminalNode { + return s.GetToken(MySqlParserWHERE, 0) +} + +func (s *SingleDeleteStatementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *SingleDeleteStatementContext) OrderByClause() IOrderByClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOrderByClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOrderByClauseContext) +} + +func (s *SingleDeleteStatementContext) LIMIT() antlr.TerminalNode { + return s.GetToken(MySqlParserLIMIT, 0) +} + +func (s *SingleDeleteStatementContext) LimitClauseAtom() ILimitClauseAtomContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILimitClauseAtomContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILimitClauseAtomContext) +} + +func (s *SingleDeleteStatementContext) LOW_PRIORITY() antlr.TerminalNode { + return s.GetToken(MySqlParserLOW_PRIORITY, 0) +} + +func (s *SingleDeleteStatementContext) AS() antlr.TerminalNode { + return s.GetToken(MySqlParserAS, 0) +} + +func (s *SingleDeleteStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SingleDeleteStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SingleDeleteStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSingleDeleteStatement(s) + } +} + +func (s *SingleDeleteStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSingleDeleteStatement(s) + } +} + +func (p *MySqlParser) SingleDeleteStatement() (localctx ISingleDeleteStatementContext) { + localctx = NewSingleDeleteStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 214, MySqlParserRULE_singleDeleteStatement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3537) + p.Match(MySqlParserDELETE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3539) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserLOW_PRIORITY { + { + p.SetState(3538) + + var _m = p.Match(MySqlParserLOW_PRIORITY) + + localctx.(*SingleDeleteStatementContext).priority = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3542) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserQUICK { + { + p.SetState(3541) + p.Match(MySqlParserQUICK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3545) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserIGNORE { + { + p.SetState(3544) + p.Match(MySqlParserIGNORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3547) + p.Match(MySqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3548) + p.TableName() + } + p.SetState(3553) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 492, p.GetParserRuleContext()) == 1 { + p.SetState(3550) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserAS { + { + p.SetState(3549) + p.Match(MySqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3552) + p.Uid() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3560) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserPARTITION { + { + p.SetState(3555) + p.Match(MySqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3556) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3557) + p.UidList() + } + { + p.SetState(3558) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3564) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserWHERE { + { + p.SetState(3562) + p.Match(MySqlParserWHERE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3563) + p.expression(0) + } + + } + p.SetState(3567) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserORDER { + { + p.SetState(3566) + p.OrderByClause() + } + + } + p.SetState(3571) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserLIMIT { + { + p.SetState(3569) + p.Match(MySqlParserLIMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3570) + p.LimitClauseAtom() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMultipleDeleteStatementContext is an interface to support dynamic dispatch. +type IMultipleDeleteStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPriority returns the priority token. + GetPriority() antlr.Token + + // SetPriority sets the priority token. + SetPriority(antlr.Token) + + // Getter signatures + DELETE() antlr.TerminalNode + AllTableName() []ITableNameContext + TableName(i int) ITableNameContext + FROM() antlr.TerminalNode + TableSources() ITableSourcesContext + USING() antlr.TerminalNode + QUICK() antlr.TerminalNode + IGNORE() antlr.TerminalNode + WHERE() antlr.TerminalNode + Expression() IExpressionContext + LOW_PRIORITY() antlr.TerminalNode + AllDOT() []antlr.TerminalNode + DOT(i int) antlr.TerminalNode + AllSTAR() []antlr.TerminalNode + STAR(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsMultipleDeleteStatementContext differentiates from other interfaces. + IsMultipleDeleteStatementContext() +} + +type MultipleDeleteStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + priority antlr.Token +} + +func NewEmptyMultipleDeleteStatementContext() *MultipleDeleteStatementContext { + var p = new(MultipleDeleteStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_multipleDeleteStatement + return p +} + +func InitEmptyMultipleDeleteStatementContext(p *MultipleDeleteStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_multipleDeleteStatement +} + +func (*MultipleDeleteStatementContext) IsMultipleDeleteStatementContext() {} + +func NewMultipleDeleteStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MultipleDeleteStatementContext { + var p = new(MultipleDeleteStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_multipleDeleteStatement + + return p +} + +func (s *MultipleDeleteStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *MultipleDeleteStatementContext) GetPriority() antlr.Token { return s.priority } + +func (s *MultipleDeleteStatementContext) SetPriority(v antlr.Token) { s.priority = v } + +func (s *MultipleDeleteStatementContext) DELETE() antlr.TerminalNode { + return s.GetToken(MySqlParserDELETE, 0) +} + +func (s *MultipleDeleteStatementContext) AllTableName() []ITableNameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITableNameContext); ok { + len++ + } + } + + tst := make([]ITableNameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITableNameContext); ok { + tst[i] = t.(ITableNameContext) + i++ + } + } + + return tst +} + +func (s *MultipleDeleteStatementContext) TableName(i int) ITableNameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableNameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITableNameContext) +} + +func (s *MultipleDeleteStatementContext) FROM() antlr.TerminalNode { + return s.GetToken(MySqlParserFROM, 0) +} + +func (s *MultipleDeleteStatementContext) TableSources() ITableSourcesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableSourcesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableSourcesContext) +} + +func (s *MultipleDeleteStatementContext) USING() antlr.TerminalNode { + return s.GetToken(MySqlParserUSING, 0) +} + +func (s *MultipleDeleteStatementContext) QUICK() antlr.TerminalNode { + return s.GetToken(MySqlParserQUICK, 0) +} + +func (s *MultipleDeleteStatementContext) IGNORE() antlr.TerminalNode { + return s.GetToken(MySqlParserIGNORE, 0) +} + +func (s *MultipleDeleteStatementContext) WHERE() antlr.TerminalNode { + return s.GetToken(MySqlParserWHERE, 0) +} + +func (s *MultipleDeleteStatementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *MultipleDeleteStatementContext) LOW_PRIORITY() antlr.TerminalNode { + return s.GetToken(MySqlParserLOW_PRIORITY, 0) +} + +func (s *MultipleDeleteStatementContext) AllDOT() []antlr.TerminalNode { + return s.GetTokens(MySqlParserDOT) +} + +func (s *MultipleDeleteStatementContext) DOT(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserDOT, i) +} + +func (s *MultipleDeleteStatementContext) AllSTAR() []antlr.TerminalNode { + return s.GetTokens(MySqlParserSTAR) +} + +func (s *MultipleDeleteStatementContext) STAR(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserSTAR, i) +} + +func (s *MultipleDeleteStatementContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *MultipleDeleteStatementContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *MultipleDeleteStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MultipleDeleteStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *MultipleDeleteStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterMultipleDeleteStatement(s) + } +} + +func (s *MultipleDeleteStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitMultipleDeleteStatement(s) + } +} + +func (p *MySqlParser) MultipleDeleteStatement() (localctx IMultipleDeleteStatementContext) { + localctx = NewMultipleDeleteStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 216, MySqlParserRULE_multipleDeleteStatement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3573) + p.Match(MySqlParserDELETE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3575) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserLOW_PRIORITY { + { + p.SetState(3574) + + var _m = p.Match(MySqlParserLOW_PRIORITY) + + localctx.(*MultipleDeleteStatementContext).priority = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3578) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 498, p.GetParserRuleContext()) == 1 { + { + p.SetState(3577) + p.Match(MySqlParserQUICK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3581) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserIGNORE { + { + p.SetState(3580) + p.Match(MySqlParserIGNORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3622) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserARRAY, MySqlParserATTRIBUTE, MySqlParserBUCKETS, MySqlParserCONDITION, MySqlParserCURRENT, MySqlParserCURRENT_USER, MySqlParserDATABASE, MySqlParserDEFAULT, MySqlParserDIAGNOSTICS, MySqlParserEMPTY, MySqlParserENFORCED, MySqlParserEXCEPT, MySqlParserGROUP, MySqlParserIF, MySqlParserIGNORED, MySqlParserINSERT, MySqlParserLATERAL, MySqlParserLEFT, MySqlParserNUMBER, MySqlParserOPTIONAL, MySqlParserORDER, MySqlParserPRIMARY, MySqlParserREPEAT, MySqlParserREPLACE, MySqlParserRIGHT, MySqlParserSCHEMA, MySqlParserSKIP_QUERY_REWRITE, MySqlParserSTACKED, MySqlParserSTATEMENT, MySqlParserDATE, MySqlParserTIME, MySqlParserTIMESTAMP, MySqlParserDATETIME, MySqlParserYEAR, MySqlParserBINARY, MySqlParserTEXT, MySqlParserENUM, MySqlParserSERIAL, MySqlParserJSON_ARRAY, MySqlParserJSON_ARRAYAGG, MySqlParserJSON_ARRAY_APPEND, MySqlParserJSON_ARRAY_INSERT, MySqlParserJSON_CONTAINS, MySqlParserJSON_CONTAINS_PATH, MySqlParserJSON_DEPTH, MySqlParserJSON_EXTRACT, MySqlParserJSON_INSERT, MySqlParserJSON_KEYS, MySqlParserJSON_LENGTH, MySqlParserJSON_MERGE, MySqlParserJSON_MERGE_PATCH, MySqlParserJSON_MERGE_PRESERVE, MySqlParserJSON_OBJECT, MySqlParserJSON_OBJECTAGG, MySqlParserJSON_OVERLAPS, MySqlParserJSON_PRETTY, MySqlParserJSON_QUOTE, MySqlParserJSON_REMOVE, MySqlParserJSON_REPLACE, MySqlParserJSON_SCHEMA_VALID, MySqlParserJSON_SCHEMA_VALIDATION_REPORT, MySqlParserJSON_SEARCH, MySqlParserJSON_SET, MySqlParserJSON_STORAGE_FREE, MySqlParserJSON_STORAGE_SIZE, MySqlParserJSON_TABLE, MySqlParserJSON_TYPE, MySqlParserJSON_UNQUOTE, MySqlParserJSON_VALID, MySqlParserJSON_VALUE, MySqlParserNESTED, MySqlParserORDINALITY, MySqlParserPATH, MySqlParserAVG, MySqlParserBIT_AND, MySqlParserBIT_OR, MySqlParserBIT_XOR, MySqlParserCOUNT, MySqlParserCUME_DIST, MySqlParserDENSE_RANK, MySqlParserFIRST_VALUE, MySqlParserGROUP_CONCAT, MySqlParserLAG, MySqlParserLAST_VALUE, MySqlParserLEAD, MySqlParserMAX, MySqlParserMIN, MySqlParserNTILE, MySqlParserNTH_VALUE, MySqlParserPERCENT_RANK, MySqlParserRANK, MySqlParserROW_NUMBER, MySqlParserSTD, MySqlParserSTDDEV, MySqlParserSTDDEV_POP, MySqlParserSTDDEV_SAMP, MySqlParserSUM, MySqlParserVAR_POP, MySqlParserVAR_SAMP, MySqlParserVARIANCE, MySqlParserCURRENT_DATE, MySqlParserCURRENT_TIME, MySqlParserCURRENT_TIMESTAMP, MySqlParserLOCALTIME, MySqlParserCURDATE, MySqlParserCURTIME, MySqlParserDATE_ADD, MySqlParserDATE_SUB, MySqlParserLOCALTIMESTAMP, MySqlParserNOW, MySqlParserPOSITION, MySqlParserSUBSTR, MySqlParserSUBSTRING, MySqlParserSYSDATE, MySqlParserTRIM, MySqlParserUTC_DATE, MySqlParserUTC_TIME, MySqlParserUTC_TIMESTAMP, MySqlParserACCOUNT, MySqlParserACTION, MySqlParserAFTER, MySqlParserAGGREGATE, MySqlParserALGORITHM, MySqlParserANY, MySqlParserAT, MySqlParserAUTHORS, MySqlParserAUTOCOMMIT, MySqlParserAUTOEXTEND_SIZE, MySqlParserAUTO_INCREMENT, MySqlParserAVG_ROW_LENGTH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserBIT, MySqlParserBLOCK, MySqlParserBOOL, MySqlParserBOOLEAN, MySqlParserBTREE, MySqlParserCACHE, MySqlParserCASCADED, MySqlParserCHAIN, MySqlParserCHANGED, MySqlParserCHANNEL, MySqlParserCHECKSUM, MySqlParserPAGE_CHECKSUM, MySqlParserCIPHER, MySqlParserCLASS_ORIGIN, MySqlParserCLIENT, MySqlParserCLOSE, MySqlParserCLUSTERING, MySqlParserCOALESCE, MySqlParserCODE, MySqlParserCOLUMNS, MySqlParserCOLUMN_FORMAT, MySqlParserCOLUMN_NAME, MySqlParserCOMMENT, MySqlParserCOMMIT, MySqlParserCOMPACT, MySqlParserCOMPLETION, MySqlParserCOMPRESSED, MySqlParserCOMPRESSION, MySqlParserCONCURRENT, MySqlParserCONNECT, MySqlParserCONNECTION, MySqlParserCONSISTENT, MySqlParserCONSTRAINT_CATALOG, MySqlParserCONSTRAINT_SCHEMA, MySqlParserCONSTRAINT_NAME, MySqlParserCONTAINS, MySqlParserCONTEXT, MySqlParserCONTRIBUTORS, MySqlParserCOPY, MySqlParserCPU, MySqlParserCURSOR_NAME, MySqlParserDATA, MySqlParserDATAFILE, MySqlParserDEALLOCATE, MySqlParserDEFAULT_AUTH, MySqlParserDEFINER, MySqlParserDELAY_KEY_WRITE, MySqlParserDES_KEY_FILE, MySqlParserDIRECTORY, MySqlParserDISABLE, MySqlParserDISCARD, MySqlParserDISK, MySqlParserDO, MySqlParserDUMPFILE, MySqlParserDUPLICATE, MySqlParserDYNAMIC, MySqlParserENABLE, MySqlParserENCRYPTION, MySqlParserEND, MySqlParserENDS, MySqlParserENGINE, MySqlParserENGINES, MySqlParserERROR, MySqlParserERRORS, MySqlParserESCAPE, MySqlParserEVEN, MySqlParserEVENT, MySqlParserEVENTS, MySqlParserEVERY, MySqlParserEXCHANGE, MySqlParserEXCLUSIVE, MySqlParserEXPIRE, MySqlParserEXPORT, MySqlParserEXTENDED, MySqlParserEXTENT_SIZE, MySqlParserFAILED_LOGIN_ATTEMPTS, MySqlParserFAST, MySqlParserFAULTS, MySqlParserFIELDS, MySqlParserFILE_BLOCK_SIZE, MySqlParserFILTER, MySqlParserFIRST, MySqlParserFIXED, MySqlParserFLUSH, MySqlParserFOLLOWS, MySqlParserFOUND, MySqlParserFULL, MySqlParserFUNCTION, MySqlParserGENERAL, MySqlParserGLOBAL, MySqlParserGRANTS, MySqlParserGROUP_REPLICATION, MySqlParserHANDLER, MySqlParserHASH, MySqlParserHELP, MySqlParserHISTORY, MySqlParserHOST, MySqlParserHOSTS, MySqlParserIDENTIFIED, MySqlParserIGNORE_SERVER_IDS, MySqlParserIMPORT, MySqlParserINDEXES, MySqlParserINITIAL_SIZE, MySqlParserINPLACE, MySqlParserINSERT_METHOD, MySqlParserINSTALL, MySqlParserINSTANCE, MySqlParserINSTANT, MySqlParserINVISIBLE, MySqlParserINVOKER, MySqlParserIO, MySqlParserIO_THREAD, MySqlParserIPC, MySqlParserISOLATION, MySqlParserISSUER, MySqlParserJSON, MySqlParserKEY_BLOCK_SIZE, MySqlParserLANGUAGE, MySqlParserLAST, MySqlParserLEAVES, MySqlParserLESS, MySqlParserLEVEL, MySqlParserLIST, MySqlParserLOCAL, MySqlParserLOGFILE, MySqlParserLOGS, MySqlParserMASTER, MySqlParserMASTER_AUTO_POSITION, MySqlParserMASTER_CONNECT_RETRY, MySqlParserMASTER_DELAY, MySqlParserMASTER_HEARTBEAT_PERIOD, MySqlParserMASTER_HOST, MySqlParserMASTER_LOG_FILE, MySqlParserMASTER_LOG_POS, MySqlParserMASTER_PASSWORD, MySqlParserMASTER_PORT, MySqlParserMASTER_RETRY_COUNT, MySqlParserMASTER_SSL, MySqlParserMASTER_SSL_CA, MySqlParserMASTER_SSL_CAPATH, MySqlParserMASTER_SSL_CERT, MySqlParserMASTER_SSL_CIPHER, MySqlParserMASTER_SSL_CRL, MySqlParserMASTER_SSL_CRLPATH, MySqlParserMASTER_SSL_KEY, MySqlParserMASTER_TLS_VERSION, MySqlParserMASTER_USER, MySqlParserMAX_CONNECTIONS_PER_HOUR, MySqlParserMAX_QUERIES_PER_HOUR, MySqlParserMAX_ROWS, MySqlParserMAX_SIZE, MySqlParserMAX_UPDATES_PER_HOUR, MySqlParserMAX_USER_CONNECTIONS, MySqlParserMEDIUM, MySqlParserMEMBER, MySqlParserMERGE, MySqlParserMESSAGE_TEXT, MySqlParserMID, MySqlParserMIGRATE, MySqlParserMIN_ROWS, MySqlParserMODE, MySqlParserMODIFY, MySqlParserMUTEX, MySqlParserMYSQL, MySqlParserMYSQL_ERRNO, MySqlParserNAME, MySqlParserNAMES, MySqlParserNCHAR, MySqlParserNEVER, MySqlParserNEXT, MySqlParserNO, MySqlParserNOCOPY, MySqlParserNOWAIT, MySqlParserNODEGROUP, MySqlParserNONE, MySqlParserODBC, MySqlParserOFFLINE, MySqlParserOFFSET, MySqlParserOF, MySqlParserOJ, MySqlParserOLD_PASSWORD, MySqlParserONE, MySqlParserONLINE, MySqlParserONLY, MySqlParserOPEN, MySqlParserOPTIMIZER_COSTS, MySqlParserOPTIONS, MySqlParserOWNER, MySqlParserPACK_KEYS, MySqlParserPAGE, MySqlParserPARSER, MySqlParserPARTIAL, MySqlParserPARTITIONING, MySqlParserPARTITIONS, MySqlParserPASSWORD, MySqlParserPASSWORD_LOCK_TIME, MySqlParserPHASE, MySqlParserPLUGIN, MySqlParserPLUGIN_DIR, MySqlParserPLUGINS, MySqlParserPORT, MySqlParserPRECEDES, MySqlParserPREPARE, MySqlParserPRESERVE, MySqlParserPREV, MySqlParserPROCESSLIST, MySqlParserPROFILE, MySqlParserPROFILES, MySqlParserPROXY, MySqlParserQUERY, MySqlParserQUICK, MySqlParserREBUILD, MySqlParserRECOVER, MySqlParserRECURSIVE, MySqlParserREDO_BUFFER_SIZE, MySqlParserREDUNDANT, MySqlParserRELAY, MySqlParserRELAY_LOG_FILE, MySqlParserRELAY_LOG_POS, MySqlParserRELAYLOG, MySqlParserREMOVE, MySqlParserREORGANIZE, MySqlParserREPAIR, MySqlParserREPLICATE_DO_DB, MySqlParserREPLICATE_DO_TABLE, MySqlParserREPLICATE_IGNORE_DB, MySqlParserREPLICATE_IGNORE_TABLE, MySqlParserREPLICATE_REWRITE_DB, MySqlParserREPLICATE_WILD_DO_TABLE, MySqlParserREPLICATE_WILD_IGNORE_TABLE, MySqlParserREPLICATION, MySqlParserRESET, MySqlParserRESUME, MySqlParserRETURNED_SQLSTATE, MySqlParserRETURNING, MySqlParserRETURNS, MySqlParserREUSE, MySqlParserROLE, MySqlParserROLLBACK, MySqlParserROLLUP, MySqlParserROTATE, MySqlParserROW, MySqlParserROWS, MySqlParserROW_FORMAT, MySqlParserRTREE, MySqlParserSAVEPOINT, MySqlParserSCHEDULE, MySqlParserSECURITY, MySqlParserSERVER, MySqlParserSESSION, MySqlParserSHARE, MySqlParserSHARED, MySqlParserSIGNED, MySqlParserSIMPLE, MySqlParserSLAVE, MySqlParserSLOW, MySqlParserSNAPSHOT, MySqlParserSOCKET, MySqlParserSOME, MySqlParserSONAME, MySqlParserSOUNDS, MySqlParserSOURCE, MySqlParserSQL_AFTER_GTIDS, MySqlParserSQL_AFTER_MTS_GAPS, MySqlParserSQL_BEFORE_GTIDS, MySqlParserSQL_BUFFER_RESULT, MySqlParserSQL_CACHE, MySqlParserSQL_NO_CACHE, MySqlParserSQL_THREAD, MySqlParserSTART, MySqlParserSTARTS, MySqlParserSTATS_AUTO_RECALC, MySqlParserSTATS_PERSISTENT, MySqlParserSTATS_SAMPLE_PAGES, MySqlParserSTATUS, MySqlParserSTOP, MySqlParserSTORAGE, MySqlParserSTRING, MySqlParserSUBCLASS_ORIGIN, MySqlParserSUBJECT, MySqlParserSUBPARTITION, MySqlParserSUBPARTITIONS, MySqlParserSUSPEND, MySqlParserSWAPS, MySqlParserSWITCHES, MySqlParserTABLE_NAME, MySqlParserTABLESPACE, MySqlParserTABLE_TYPE, MySqlParserTEMPORARY, MySqlParserTEMPTABLE, MySqlParserTHAN, MySqlParserTRADITIONAL, MySqlParserTRANSACTION, MySqlParserTRANSACTIONAL, MySqlParserTRIGGERS, MySqlParserTRUNCATE, MySqlParserUNBOUNDED, MySqlParserUNDEFINED, MySqlParserUNDOFILE, MySqlParserUNDO_BUFFER_SIZE, MySqlParserUNINSTALL, MySqlParserUNKNOWN, MySqlParserUNTIL, MySqlParserUPGRADE, MySqlParserUSER, MySqlParserUSE_FRM, MySqlParserUSER_RESOURCES, MySqlParserVALIDATION, MySqlParserVALUE, MySqlParserVARIABLES, MySqlParserVIEW, MySqlParserVIRTUAL, MySqlParserVISIBLE, MySqlParserWAIT, MySqlParserWARNINGS, MySqlParserWITHOUT, MySqlParserWORK, MySqlParserWRAPPER, MySqlParserX509, MySqlParserXA, MySqlParserXML, MySqlParserYES, MySqlParserEUR, MySqlParserUSA, MySqlParserJIS, MySqlParserISO, MySqlParserINTERNAL, MySqlParserQUARTER, MySqlParserMONTH, MySqlParserDAY, MySqlParserHOUR, MySqlParserMINUTE, MySqlParserWEEK, MySqlParserSECOND, MySqlParserMICROSECOND, MySqlParserADMIN, MySqlParserAUDIT_ABORT_EXEMPT, MySqlParserAUDIT_ADMIN, MySqlParserAUTHENTICATION_POLICY_ADMIN, MySqlParserBACKUP_ADMIN, MySqlParserBINLOG_ADMIN, MySqlParserBINLOG_ENCRYPTION_ADMIN, MySqlParserCLONE_ADMIN, MySqlParserCONNECTION_ADMIN, MySqlParserENCRYPTION_KEY_ADMIN, MySqlParserEXECUTE, MySqlParserFILE, MySqlParserFIREWALL_ADMIN, MySqlParserFIREWALL_EXEMPT, MySqlParserFIREWALL_USER, MySqlParserGROUP_REPLICATION_ADMIN, MySqlParserINNODB_REDO_LOG_ARCHIVE, MySqlParserINVOKE, MySqlParserLAMBDA, MySqlParserNDB_STORED_USER, MySqlParserPASSWORDLESS_USER_ADMIN, MySqlParserPERSIST_RO_VARIABLES_ADMIN, MySqlParserPRIVILEGES, MySqlParserPROCESS, MySqlParserRELOAD, MySqlParserREPLICATION_APPLIER, MySqlParserREPLICATION_SLAVE_ADMIN, MySqlParserRESOURCE_GROUP_ADMIN, MySqlParserRESOURCE_GROUP_USER, MySqlParserROLE_ADMIN, MySqlParserROUTINE, MySqlParserS3, MySqlParserSESSION_VARIABLES_ADMIN, MySqlParserSET_USER_ID, MySqlParserSHOW_ROUTINE, MySqlParserSHUTDOWN, MySqlParserSUPER, MySqlParserSYSTEM_VARIABLES_ADMIN, MySqlParserTABLES, MySqlParserTABLE_ENCRYPTION_ADMIN, MySqlParserVERSION_TOKEN_ADMIN, MySqlParserXA_RECOVER_ADMIN, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserARCHIVE, MySqlParserBLACKHOLE, MySqlParserCSV, MySqlParserFEDERATED, MySqlParserINNODB, MySqlParserMEMORY, MySqlParserMRG_MYISAM, MySqlParserMYISAM, MySqlParserNDB, MySqlParserNDBCLUSTER, MySqlParserPERFORMANCE_SCHEMA, MySqlParserTOKUDB, MySqlParserREPEATABLE, MySqlParserCOMMITTED, MySqlParserUNCOMMITTED, MySqlParserSERIALIZABLE, MySqlParserGEOMETRYCOLLECTION, MySqlParserLINESTRING, MySqlParserMULTILINESTRING, MySqlParserMULTIPOINT, MySqlParserMULTIPOLYGON, MySqlParserPOINT, MySqlParserPOLYGON, MySqlParserABS, MySqlParserACOS, MySqlParserADDDATE, MySqlParserADDTIME, MySqlParserAES_DECRYPT, MySqlParserAES_ENCRYPT, MySqlParserAREA, MySqlParserASBINARY, MySqlParserASIN, MySqlParserASTEXT, MySqlParserASWKB, MySqlParserASWKT, MySqlParserASYMMETRIC_DECRYPT, MySqlParserASYMMETRIC_DERIVE, MySqlParserASYMMETRIC_ENCRYPT, MySqlParserASYMMETRIC_SIGN, MySqlParserASYMMETRIC_VERIFY, MySqlParserATAN, MySqlParserATAN2, MySqlParserBENCHMARK, MySqlParserBIN, MySqlParserBIT_COUNT, MySqlParserBIT_LENGTH, MySqlParserBUFFER, MySqlParserCATALOG_NAME, MySqlParserCEIL, MySqlParserCEILING, MySqlParserCENTROID, MySqlParserCHARACTER_LENGTH, MySqlParserCHARSET, MySqlParserCHAR_LENGTH, MySqlParserCOERCIBILITY, MySqlParserCOLLATION, MySqlParserCOMPRESS, MySqlParserCONCAT, MySqlParserCONCAT_WS, MySqlParserCONNECTION_ID, MySqlParserCONV, MySqlParserCONVERT_TZ, MySqlParserCOS, MySqlParserCOT, MySqlParserCRC32, MySqlParserCREATE_ASYMMETRIC_PRIV_KEY, MySqlParserCREATE_ASYMMETRIC_PUB_KEY, MySqlParserCREATE_DH_PARAMETERS, MySqlParserCREATE_DIGEST, MySqlParserCROSSES, MySqlParserDATEDIFF, MySqlParserDATE_FORMAT, MySqlParserDAYNAME, MySqlParserDAYOFMONTH, MySqlParserDAYOFWEEK, MySqlParserDAYOFYEAR, MySqlParserDECODE, MySqlParserDEGREES, MySqlParserDES_DECRYPT, MySqlParserDES_ENCRYPT, MySqlParserDIMENSION, MySqlParserDISJOINT, MySqlParserDISTANCE, MySqlParserELT, MySqlParserENCODE, MySqlParserENCRYPT, MySqlParserENDPOINT, MySqlParserENGINE_ATTRIBUTE, MySqlParserENVELOPE, MySqlParserEQUALS, MySqlParserEXP, MySqlParserEXPORT_SET, MySqlParserEXTERIORRING, MySqlParserEXTRACTVALUE, MySqlParserFIELD, MySqlParserFIND_IN_SET, MySqlParserFLOOR, MySqlParserFORMAT, MySqlParserFOUND_ROWS, MySqlParserFROM_BASE64, MySqlParserFROM_DAYS, MySqlParserFROM_UNIXTIME, MySqlParserGEOMCOLLFROMTEXT, MySqlParserGEOMCOLLFROMWKB, MySqlParserGEOMETRYCOLLECTIONFROMTEXT, MySqlParserGEOMETRYCOLLECTIONFROMWKB, MySqlParserGEOMETRYFROMTEXT, MySqlParserGEOMETRYFROMWKB, MySqlParserGEOMETRYN, MySqlParserGEOMETRYTYPE, MySqlParserGEOMFROMTEXT, MySqlParserGEOMFROMWKB, MySqlParserGET_FORMAT, MySqlParserGET_LOCK, MySqlParserGLENGTH, MySqlParserGREATEST, MySqlParserGTID_SUBSET, MySqlParserGTID_SUBTRACT, MySqlParserHEX, MySqlParserIFNULL, MySqlParserINET6_ATON, MySqlParserINET6_NTOA, MySqlParserINET_ATON, MySqlParserINET_NTOA, MySqlParserINSTR, MySqlParserINTERIORRINGN, MySqlParserINTERSECTS, MySqlParserISCLOSED, MySqlParserISEMPTY, MySqlParserISNULL, MySqlParserISSIMPLE, MySqlParserIS_FREE_LOCK, MySqlParserIS_IPV4, MySqlParserIS_IPV4_COMPAT, MySqlParserIS_IPV4_MAPPED, MySqlParserIS_IPV6, MySqlParserIS_USED_LOCK, MySqlParserLAST_INSERT_ID, MySqlParserLCASE, MySqlParserLEAST, MySqlParserLENGTH, MySqlParserLINEFROMTEXT, MySqlParserLINEFROMWKB, MySqlParserLINESTRINGFROMTEXT, MySqlParserLINESTRINGFROMWKB, MySqlParserLN, MySqlParserLOAD_FILE, MySqlParserLOCATE, MySqlParserLOG, MySqlParserLOG10, MySqlParserLOG2, MySqlParserLOWER, MySqlParserLPAD, MySqlParserLTRIM, MySqlParserMAKEDATE, MySqlParserMAKETIME, MySqlParserMAKE_SET, MySqlParserMASTER_POS_WAIT, MySqlParserMBRCONTAINS, MySqlParserMBRDISJOINT, MySqlParserMBREQUAL, MySqlParserMBRINTERSECTS, MySqlParserMBROVERLAPS, MySqlParserMBRTOUCHES, MySqlParserMBRWITHIN, MySqlParserMD5, MySqlParserMLINEFROMTEXT, MySqlParserMLINEFROMWKB, MySqlParserMONTHNAME, MySqlParserMPOINTFROMTEXT, MySqlParserMPOINTFROMWKB, MySqlParserMPOLYFROMTEXT, MySqlParserMPOLYFROMWKB, MySqlParserMULTILINESTRINGFROMTEXT, MySqlParserMULTILINESTRINGFROMWKB, MySqlParserMULTIPOINTFROMTEXT, MySqlParserMULTIPOINTFROMWKB, MySqlParserMULTIPOLYGONFROMTEXT, MySqlParserMULTIPOLYGONFROMWKB, MySqlParserNAME_CONST, MySqlParserNULLIF, MySqlParserNUMGEOMETRIES, MySqlParserNUMINTERIORRINGS, MySqlParserNUMPOINTS, MySqlParserOCT, MySqlParserOCTET_LENGTH, MySqlParserORD, MySqlParserOVERLAPS, MySqlParserPERIOD_ADD, MySqlParserPERIOD_DIFF, MySqlParserPI, MySqlParserPOINTFROMTEXT, MySqlParserPOINTFROMWKB, MySqlParserPOINTN, MySqlParserPOLYFROMTEXT, MySqlParserPOLYFROMWKB, MySqlParserPOLYGONFROMTEXT, MySqlParserPOLYGONFROMWKB, MySqlParserPOW, MySqlParserPOWER, MySqlParserQUOTE, MySqlParserRADIANS, MySqlParserRAND, MySqlParserRANDOM, MySqlParserRANDOM_BYTES, MySqlParserRELEASE_LOCK, MySqlParserREVERSE, MySqlParserROUND, MySqlParserROW_COUNT, MySqlParserRPAD, MySqlParserRTRIM, MySqlParserSEC_TO_TIME, MySqlParserSECONDARY_ENGINE_ATTRIBUTE, MySqlParserSESSION_USER, MySqlParserSHA, MySqlParserSHA1, MySqlParserSHA2, MySqlParserSCHEMA_NAME, MySqlParserSIGN, MySqlParserSIN, MySqlParserSLEEP, MySqlParserSOUNDEX, MySqlParserSQL_THREAD_WAIT_AFTER_GTIDS, MySqlParserSQRT, MySqlParserSRID, MySqlParserSTARTPOINT, MySqlParserSTRCMP, MySqlParserSTR_TO_DATE, MySqlParserST_AREA, MySqlParserST_ASBINARY, MySqlParserST_ASTEXT, MySqlParserST_ASWKB, MySqlParserST_ASWKT, MySqlParserST_BUFFER, MySqlParserST_CENTROID, MySqlParserST_CONTAINS, MySqlParserST_CROSSES, MySqlParserST_DIFFERENCE, MySqlParserST_DIMENSION, MySqlParserST_DISJOINT, MySqlParserST_DISTANCE, MySqlParserST_ENDPOINT, MySqlParserST_ENVELOPE, MySqlParserST_EQUALS, MySqlParserST_EXTERIORRING, MySqlParserST_GEOMCOLLFROMTEXT, MySqlParserST_GEOMCOLLFROMTXT, MySqlParserST_GEOMCOLLFROMWKB, MySqlParserST_GEOMETRYCOLLECTIONFROMTEXT, MySqlParserST_GEOMETRYCOLLECTIONFROMWKB, MySqlParserST_GEOMETRYFROMTEXT, MySqlParserST_GEOMETRYFROMWKB, MySqlParserST_GEOMETRYN, MySqlParserST_GEOMETRYTYPE, MySqlParserST_GEOMFROMTEXT, MySqlParserST_GEOMFROMWKB, MySqlParserST_INTERIORRINGN, MySqlParserST_INTERSECTION, MySqlParserST_INTERSECTS, MySqlParserST_ISCLOSED, MySqlParserST_ISEMPTY, MySqlParserST_ISSIMPLE, MySqlParserST_LINEFROMTEXT, MySqlParserST_LINEFROMWKB, MySqlParserST_LINESTRINGFROMTEXT, MySqlParserST_LINESTRINGFROMWKB, MySqlParserST_NUMGEOMETRIES, MySqlParserST_NUMINTERIORRING, MySqlParserST_NUMINTERIORRINGS, MySqlParserST_NUMPOINTS, MySqlParserST_OVERLAPS, MySqlParserST_POINTFROMTEXT, MySqlParserST_POINTFROMWKB, MySqlParserST_POINTN, MySqlParserST_POLYFROMTEXT, MySqlParserST_POLYFROMWKB, MySqlParserST_POLYGONFROMTEXT, MySqlParserST_POLYGONFROMWKB, MySqlParserST_SRID, MySqlParserST_STARTPOINT, MySqlParserST_SYMDIFFERENCE, MySqlParserST_TOUCHES, MySqlParserST_UNION, MySqlParserST_WITHIN, MySqlParserST_X, MySqlParserST_Y, MySqlParserSTRING_TO_VECTOR, MySqlParserSUBDATE, MySqlParserSUBSTRING_INDEX, MySqlParserSUBTIME, MySqlParserSYSTEM_USER, MySqlParserTAN, MySqlParserTIMEDIFF, MySqlParserTIMESTAMPADD, MySqlParserTIMESTAMPDIFF, MySqlParserTIME_FORMAT, MySqlParserTIME_TO_SEC, MySqlParserTOUCHES, MySqlParserTO_BASE64, MySqlParserTO_DAYS, MySqlParserTO_SECONDS, MySqlParserTP_CONNECTION_ADMIN, MySqlParserUCASE, MySqlParserUNCOMPRESS, MySqlParserUNCOMPRESSED_LENGTH, MySqlParserUNHEX, MySqlParserUNIX_TIMESTAMP, MySqlParserUPDATEXML, MySqlParserUPPER, MySqlParserUUID, MySqlParserUUID_SHORT, MySqlParserVALIDATE_PASSWORD_STRENGTH, MySqlParserVECTOR_DIM, MySqlParserVECTOR_TO_STRING, MySqlParserVERSION, MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS, MySqlParserWEEKDAY, MySqlParserWEEKOFYEAR, MySqlParserWEIGHT_STRING, MySqlParserWITHIN, MySqlParserYEARWEEK, MySqlParserY_FUNCTION, MySqlParserX_FUNCTION, MySqlParserMOD, MySqlParserCHARSET_REVERSE_QOUTE_STRING, MySqlParserSTRING_LITERAL, MySqlParserID: + { + p.SetState(3583) + p.TableName() + } + p.SetState(3586) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserDOT { + { + p.SetState(3584) + p.Match(MySqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3585) + p.Match(MySqlParserSTAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3596) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(3588) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3589) + p.TableName() + } + p.SetState(3592) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserDOT { + { + p.SetState(3590) + p.Match(MySqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3591) + p.Match(MySqlParserSTAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + p.SetState(3598) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3599) + p.Match(MySqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3600) + p.TableSources() + } + + case MySqlParserFROM: + { + p.SetState(3602) + p.Match(MySqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3603) + p.TableName() + } + p.SetState(3606) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserDOT { + { + p.SetState(3604) + p.Match(MySqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3605) + p.Match(MySqlParserSTAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3616) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(3608) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3609) + p.TableName() + } + p.SetState(3612) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserDOT { + { + p.SetState(3610) + p.Match(MySqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3611) + p.Match(MySqlParserSTAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + p.SetState(3618) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3619) + p.Match(MySqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3620) + p.TableSources() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(3626) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserWHERE { + { + p.SetState(3624) + p.Match(MySqlParserWHERE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3625) + p.expression(0) + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHandlerOpenStatementContext is an interface to support dynamic dispatch. +type IHandlerOpenStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + HANDLER() antlr.TerminalNode + TableName() ITableNameContext + OPEN() antlr.TerminalNode + Uid() IUidContext + AS() antlr.TerminalNode + + // IsHandlerOpenStatementContext differentiates from other interfaces. + IsHandlerOpenStatementContext() +} + +type HandlerOpenStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHandlerOpenStatementContext() *HandlerOpenStatementContext { + var p = new(HandlerOpenStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_handlerOpenStatement + return p +} + +func InitEmptyHandlerOpenStatementContext(p *HandlerOpenStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_handlerOpenStatement +} + +func (*HandlerOpenStatementContext) IsHandlerOpenStatementContext() {} + +func NewHandlerOpenStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *HandlerOpenStatementContext { + var p = new(HandlerOpenStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_handlerOpenStatement + + return p +} + +func (s *HandlerOpenStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *HandlerOpenStatementContext) HANDLER() antlr.TerminalNode { + return s.GetToken(MySqlParserHANDLER, 0) +} + +func (s *HandlerOpenStatementContext) TableName() ITableNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableNameContext) +} + +func (s *HandlerOpenStatementContext) OPEN() antlr.TerminalNode { + return s.GetToken(MySqlParserOPEN, 0) +} + +func (s *HandlerOpenStatementContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *HandlerOpenStatementContext) AS() antlr.TerminalNode { + return s.GetToken(MySqlParserAS, 0) +} + +func (s *HandlerOpenStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *HandlerOpenStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *HandlerOpenStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterHandlerOpenStatement(s) + } +} + +func (s *HandlerOpenStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitHandlerOpenStatement(s) + } +} + +func (p *MySqlParser) HandlerOpenStatement() (localctx IHandlerOpenStatementContext) { + localctx = NewHandlerOpenStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 218, MySqlParserRULE_handlerOpenStatement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3628) + p.Match(MySqlParserHANDLER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3629) + p.TableName() + } + { + p.SetState(3630) + p.Match(MySqlParserOPEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3635) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 509, p.GetParserRuleContext()) == 1 { + p.SetState(3632) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserAS { + { + p.SetState(3631) + p.Match(MySqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3634) + p.Uid() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHandlerReadIndexStatementContext is an interface to support dynamic dispatch. +type IHandlerReadIndexStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetMoveOrder returns the moveOrder token. + GetMoveOrder() antlr.Token + + // SetMoveOrder sets the moveOrder token. + SetMoveOrder(antlr.Token) + + // GetIndex returns the index rule contexts. + GetIndex() IUidContext + + // SetIndex sets the index rule contexts. + SetIndex(IUidContext) + + // Getter signatures + HANDLER() antlr.TerminalNode + TableName() ITableNameContext + READ() antlr.TerminalNode + Uid() IUidContext + ComparisonOperator() IComparisonOperatorContext + LR_BRACKET() antlr.TerminalNode + Constants() IConstantsContext + RR_BRACKET() antlr.TerminalNode + WHERE() antlr.TerminalNode + Expression() IExpressionContext + LIMIT() antlr.TerminalNode + LimitClauseAtom() ILimitClauseAtomContext + FIRST() antlr.TerminalNode + NEXT() antlr.TerminalNode + PREV() antlr.TerminalNode + LAST() antlr.TerminalNode + + // IsHandlerReadIndexStatementContext differentiates from other interfaces. + IsHandlerReadIndexStatementContext() +} + +type HandlerReadIndexStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + index IUidContext + moveOrder antlr.Token +} + +func NewEmptyHandlerReadIndexStatementContext() *HandlerReadIndexStatementContext { + var p = new(HandlerReadIndexStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_handlerReadIndexStatement + return p +} + +func InitEmptyHandlerReadIndexStatementContext(p *HandlerReadIndexStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_handlerReadIndexStatement +} + +func (*HandlerReadIndexStatementContext) IsHandlerReadIndexStatementContext() {} + +func NewHandlerReadIndexStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *HandlerReadIndexStatementContext { + var p = new(HandlerReadIndexStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_handlerReadIndexStatement + + return p +} + +func (s *HandlerReadIndexStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *HandlerReadIndexStatementContext) GetMoveOrder() antlr.Token { return s.moveOrder } + +func (s *HandlerReadIndexStatementContext) SetMoveOrder(v antlr.Token) { s.moveOrder = v } + +func (s *HandlerReadIndexStatementContext) GetIndex() IUidContext { return s.index } + +func (s *HandlerReadIndexStatementContext) SetIndex(v IUidContext) { s.index = v } + +func (s *HandlerReadIndexStatementContext) HANDLER() antlr.TerminalNode { + return s.GetToken(MySqlParserHANDLER, 0) +} + +func (s *HandlerReadIndexStatementContext) TableName() ITableNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableNameContext) +} + +func (s *HandlerReadIndexStatementContext) READ() antlr.TerminalNode { + return s.GetToken(MySqlParserREAD, 0) +} + +func (s *HandlerReadIndexStatementContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *HandlerReadIndexStatementContext) ComparisonOperator() IComparisonOperatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComparisonOperatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComparisonOperatorContext) +} + +func (s *HandlerReadIndexStatementContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *HandlerReadIndexStatementContext) Constants() IConstantsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstantsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstantsContext) +} + +func (s *HandlerReadIndexStatementContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *HandlerReadIndexStatementContext) WHERE() antlr.TerminalNode { + return s.GetToken(MySqlParserWHERE, 0) +} + +func (s *HandlerReadIndexStatementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *HandlerReadIndexStatementContext) LIMIT() antlr.TerminalNode { + return s.GetToken(MySqlParserLIMIT, 0) +} + +func (s *HandlerReadIndexStatementContext) LimitClauseAtom() ILimitClauseAtomContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILimitClauseAtomContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILimitClauseAtomContext) +} + +func (s *HandlerReadIndexStatementContext) FIRST() antlr.TerminalNode { + return s.GetToken(MySqlParserFIRST, 0) +} + +func (s *HandlerReadIndexStatementContext) NEXT() antlr.TerminalNode { + return s.GetToken(MySqlParserNEXT, 0) +} + +func (s *HandlerReadIndexStatementContext) PREV() antlr.TerminalNode { + return s.GetToken(MySqlParserPREV, 0) +} + +func (s *HandlerReadIndexStatementContext) LAST() antlr.TerminalNode { + return s.GetToken(MySqlParserLAST, 0) +} + +func (s *HandlerReadIndexStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *HandlerReadIndexStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *HandlerReadIndexStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterHandlerReadIndexStatement(s) + } +} + +func (s *HandlerReadIndexStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitHandlerReadIndexStatement(s) + } +} + +func (p *MySqlParser) HandlerReadIndexStatement() (localctx IHandlerReadIndexStatementContext) { + localctx = NewHandlerReadIndexStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 220, MySqlParserRULE_handlerReadIndexStatement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3637) + p.Match(MySqlParserHANDLER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3638) + p.TableName() + } + { + p.SetState(3639) + p.Match(MySqlParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3640) + + var _x = p.Uid() + + localctx.(*HandlerReadIndexStatementContext).index = _x + } + p.SetState(3647) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserEQUAL_SYMBOL, MySqlParserGREATER_SYMBOL, MySqlParserLESS_SYMBOL, MySqlParserEXCLAMATION_SYMBOL: + { + p.SetState(3641) + p.ComparisonOperator() + } + { + p.SetState(3642) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3643) + p.Constants() + } + { + p.SetState(3644) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserFIRST, MySqlParserLAST, MySqlParserNEXT, MySqlParserPREV: + { + p.SetState(3646) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*HandlerReadIndexStatementContext).moveOrder = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserFIRST || _la == MySqlParserLAST || _la == MySqlParserNEXT || _la == MySqlParserPREV) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*HandlerReadIndexStatementContext).moveOrder = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(3651) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserWHERE { + { + p.SetState(3649) + p.Match(MySqlParserWHERE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3650) + p.expression(0) + } + + } + p.SetState(3655) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserLIMIT { + { + p.SetState(3653) + p.Match(MySqlParserLIMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3654) + p.LimitClauseAtom() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHandlerReadStatementContext is an interface to support dynamic dispatch. +type IHandlerReadStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetMoveOrder returns the moveOrder token. + GetMoveOrder() antlr.Token + + // SetMoveOrder sets the moveOrder token. + SetMoveOrder(antlr.Token) + + // Getter signatures + HANDLER() antlr.TerminalNode + TableName() ITableNameContext + READ() antlr.TerminalNode + FIRST() antlr.TerminalNode + NEXT() antlr.TerminalNode + WHERE() antlr.TerminalNode + Expression() IExpressionContext + LIMIT() antlr.TerminalNode + LimitClauseAtom() ILimitClauseAtomContext + + // IsHandlerReadStatementContext differentiates from other interfaces. + IsHandlerReadStatementContext() +} + +type HandlerReadStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + moveOrder antlr.Token +} + +func NewEmptyHandlerReadStatementContext() *HandlerReadStatementContext { + var p = new(HandlerReadStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_handlerReadStatement + return p +} + +func InitEmptyHandlerReadStatementContext(p *HandlerReadStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_handlerReadStatement +} + +func (*HandlerReadStatementContext) IsHandlerReadStatementContext() {} + +func NewHandlerReadStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *HandlerReadStatementContext { + var p = new(HandlerReadStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_handlerReadStatement + + return p +} + +func (s *HandlerReadStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *HandlerReadStatementContext) GetMoveOrder() antlr.Token { return s.moveOrder } + +func (s *HandlerReadStatementContext) SetMoveOrder(v antlr.Token) { s.moveOrder = v } + +func (s *HandlerReadStatementContext) HANDLER() antlr.TerminalNode { + return s.GetToken(MySqlParserHANDLER, 0) +} + +func (s *HandlerReadStatementContext) TableName() ITableNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableNameContext) +} + +func (s *HandlerReadStatementContext) READ() antlr.TerminalNode { + return s.GetToken(MySqlParserREAD, 0) +} + +func (s *HandlerReadStatementContext) FIRST() antlr.TerminalNode { + return s.GetToken(MySqlParserFIRST, 0) +} + +func (s *HandlerReadStatementContext) NEXT() antlr.TerminalNode { + return s.GetToken(MySqlParserNEXT, 0) +} + +func (s *HandlerReadStatementContext) WHERE() antlr.TerminalNode { + return s.GetToken(MySqlParserWHERE, 0) +} + +func (s *HandlerReadStatementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *HandlerReadStatementContext) LIMIT() antlr.TerminalNode { + return s.GetToken(MySqlParserLIMIT, 0) +} + +func (s *HandlerReadStatementContext) LimitClauseAtom() ILimitClauseAtomContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILimitClauseAtomContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILimitClauseAtomContext) +} + +func (s *HandlerReadStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *HandlerReadStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *HandlerReadStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterHandlerReadStatement(s) + } +} + +func (s *HandlerReadStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitHandlerReadStatement(s) + } +} + +func (p *MySqlParser) HandlerReadStatement() (localctx IHandlerReadStatementContext) { + localctx = NewHandlerReadStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 222, MySqlParserRULE_handlerReadStatement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3657) + p.Match(MySqlParserHANDLER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3658) + p.TableName() + } + { + p.SetState(3659) + p.Match(MySqlParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3660) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*HandlerReadStatementContext).moveOrder = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserFIRST || _la == MySqlParserNEXT) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*HandlerReadStatementContext).moveOrder = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(3663) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserWHERE { + { + p.SetState(3661) + p.Match(MySqlParserWHERE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3662) + p.expression(0) + } + + } + p.SetState(3667) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserLIMIT { + { + p.SetState(3665) + p.Match(MySqlParserLIMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3666) + p.LimitClauseAtom() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHandlerCloseStatementContext is an interface to support dynamic dispatch. +type IHandlerCloseStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + HANDLER() antlr.TerminalNode + TableName() ITableNameContext + CLOSE() antlr.TerminalNode + + // IsHandlerCloseStatementContext differentiates from other interfaces. + IsHandlerCloseStatementContext() +} + +type HandlerCloseStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHandlerCloseStatementContext() *HandlerCloseStatementContext { + var p = new(HandlerCloseStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_handlerCloseStatement + return p +} + +func InitEmptyHandlerCloseStatementContext(p *HandlerCloseStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_handlerCloseStatement +} + +func (*HandlerCloseStatementContext) IsHandlerCloseStatementContext() {} + +func NewHandlerCloseStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *HandlerCloseStatementContext { + var p = new(HandlerCloseStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_handlerCloseStatement + + return p +} + +func (s *HandlerCloseStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *HandlerCloseStatementContext) HANDLER() antlr.TerminalNode { + return s.GetToken(MySqlParserHANDLER, 0) +} + +func (s *HandlerCloseStatementContext) TableName() ITableNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableNameContext) +} + +func (s *HandlerCloseStatementContext) CLOSE() antlr.TerminalNode { + return s.GetToken(MySqlParserCLOSE, 0) +} + +func (s *HandlerCloseStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *HandlerCloseStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *HandlerCloseStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterHandlerCloseStatement(s) + } +} + +func (s *HandlerCloseStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitHandlerCloseStatement(s) + } +} + +func (p *MySqlParser) HandlerCloseStatement() (localctx IHandlerCloseStatementContext) { + localctx = NewHandlerCloseStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 224, MySqlParserRULE_handlerCloseStatement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3669) + p.Match(MySqlParserHANDLER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3670) + p.TableName() + } + { + p.SetState(3671) + p.Match(MySqlParserCLOSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISingleUpdateStatementContext is an interface to support dynamic dispatch. +type ISingleUpdateStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPriority returns the priority token. + GetPriority() antlr.Token + + // SetPriority sets the priority token. + SetPriority(antlr.Token) + + // Getter signatures + UPDATE() antlr.TerminalNode + TableName() ITableNameContext + SET() antlr.TerminalNode + AllUpdatedElement() []IUpdatedElementContext + UpdatedElement(i int) IUpdatedElementContext + IGNORE() antlr.TerminalNode + Uid() IUidContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + WHERE() antlr.TerminalNode + Expression() IExpressionContext + OrderByClause() IOrderByClauseContext + LimitClause() ILimitClauseContext + LOW_PRIORITY() antlr.TerminalNode + AS() antlr.TerminalNode + + // IsSingleUpdateStatementContext differentiates from other interfaces. + IsSingleUpdateStatementContext() +} + +type SingleUpdateStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + priority antlr.Token +} + +func NewEmptySingleUpdateStatementContext() *SingleUpdateStatementContext { + var p = new(SingleUpdateStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_singleUpdateStatement + return p +} + +func InitEmptySingleUpdateStatementContext(p *SingleUpdateStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_singleUpdateStatement +} + +func (*SingleUpdateStatementContext) IsSingleUpdateStatementContext() {} + +func NewSingleUpdateStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SingleUpdateStatementContext { + var p = new(SingleUpdateStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_singleUpdateStatement + + return p +} + +func (s *SingleUpdateStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *SingleUpdateStatementContext) GetPriority() antlr.Token { return s.priority } + +func (s *SingleUpdateStatementContext) SetPriority(v antlr.Token) { s.priority = v } + +func (s *SingleUpdateStatementContext) UPDATE() antlr.TerminalNode { + return s.GetToken(MySqlParserUPDATE, 0) +} + +func (s *SingleUpdateStatementContext) TableName() ITableNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableNameContext) +} + +func (s *SingleUpdateStatementContext) SET() antlr.TerminalNode { + return s.GetToken(MySqlParserSET, 0) +} + +func (s *SingleUpdateStatementContext) AllUpdatedElement() []IUpdatedElementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUpdatedElementContext); ok { + len++ + } + } + + tst := make([]IUpdatedElementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUpdatedElementContext); ok { + tst[i] = t.(IUpdatedElementContext) + i++ + } + } + + return tst +} + +func (s *SingleUpdateStatementContext) UpdatedElement(i int) IUpdatedElementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdatedElementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUpdatedElementContext) +} + +func (s *SingleUpdateStatementContext) IGNORE() antlr.TerminalNode { + return s.GetToken(MySqlParserIGNORE, 0) +} + +func (s *SingleUpdateStatementContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *SingleUpdateStatementContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *SingleUpdateStatementContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *SingleUpdateStatementContext) WHERE() antlr.TerminalNode { + return s.GetToken(MySqlParserWHERE, 0) +} + +func (s *SingleUpdateStatementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *SingleUpdateStatementContext) OrderByClause() IOrderByClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOrderByClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOrderByClauseContext) +} + +func (s *SingleUpdateStatementContext) LimitClause() ILimitClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILimitClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILimitClauseContext) +} + +func (s *SingleUpdateStatementContext) LOW_PRIORITY() antlr.TerminalNode { + return s.GetToken(MySqlParserLOW_PRIORITY, 0) +} + +func (s *SingleUpdateStatementContext) AS() antlr.TerminalNode { + return s.GetToken(MySqlParserAS, 0) +} + +func (s *SingleUpdateStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SingleUpdateStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SingleUpdateStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSingleUpdateStatement(s) + } +} + +func (s *SingleUpdateStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSingleUpdateStatement(s) + } +} + +func (p *MySqlParser) SingleUpdateStatement() (localctx ISingleUpdateStatementContext) { + localctx = NewSingleUpdateStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 226, MySqlParserRULE_singleUpdateStatement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3673) + p.Match(MySqlParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3675) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserLOW_PRIORITY { + { + p.SetState(3674) + + var _m = p.Match(MySqlParserLOW_PRIORITY) + + localctx.(*SingleUpdateStatementContext).priority = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3678) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserIGNORE { + { + p.SetState(3677) + p.Match(MySqlParserIGNORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3680) + p.TableName() + } + p.SetState(3685) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513126400) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-34354363873) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-2199023255553) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-5764611921080745985) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-8796126576641) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-32651097298436097) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-18014398517872129) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-137438953601) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-44473063500156929) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-129) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-12289) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&-1) != 0) || ((int64((_la-1128)) & ^0x3f) == 0 && ((int64(1)<<(_la-1128))&8627683329) != 0) { + p.SetState(3682) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserAS { + { + p.SetState(3681) + p.Match(MySqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3684) + p.Uid() + } + + } + { + p.SetState(3687) + p.Match(MySqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3688) + p.UpdatedElement() + } + p.SetState(3693) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(3689) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3690) + p.UpdatedElement() + } + + p.SetState(3695) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(3698) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserWHERE { + { + p.SetState(3696) + p.Match(MySqlParserWHERE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3697) + p.expression(0) + } + + } + p.SetState(3701) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserORDER { + { + p.SetState(3700) + p.OrderByClause() + } + + } + p.SetState(3704) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserLIMIT { + { + p.SetState(3703) + p.LimitClause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMultipleUpdateStatementContext is an interface to support dynamic dispatch. +type IMultipleUpdateStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPriority returns the priority token. + GetPriority() antlr.Token + + // SetPriority sets the priority token. + SetPriority(antlr.Token) + + // Getter signatures + UPDATE() antlr.TerminalNode + TableSources() ITableSourcesContext + SET() antlr.TerminalNode + AllUpdatedElement() []IUpdatedElementContext + UpdatedElement(i int) IUpdatedElementContext + IGNORE() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + WHERE() antlr.TerminalNode + Expression() IExpressionContext + LOW_PRIORITY() antlr.TerminalNode + + // IsMultipleUpdateStatementContext differentiates from other interfaces. + IsMultipleUpdateStatementContext() +} + +type MultipleUpdateStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + priority antlr.Token +} + +func NewEmptyMultipleUpdateStatementContext() *MultipleUpdateStatementContext { + var p = new(MultipleUpdateStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_multipleUpdateStatement + return p +} + +func InitEmptyMultipleUpdateStatementContext(p *MultipleUpdateStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_multipleUpdateStatement +} + +func (*MultipleUpdateStatementContext) IsMultipleUpdateStatementContext() {} + +func NewMultipleUpdateStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MultipleUpdateStatementContext { + var p = new(MultipleUpdateStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_multipleUpdateStatement + + return p +} + +func (s *MultipleUpdateStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *MultipleUpdateStatementContext) GetPriority() antlr.Token { return s.priority } + +func (s *MultipleUpdateStatementContext) SetPriority(v antlr.Token) { s.priority = v } + +func (s *MultipleUpdateStatementContext) UPDATE() antlr.TerminalNode { + return s.GetToken(MySqlParserUPDATE, 0) +} + +func (s *MultipleUpdateStatementContext) TableSources() ITableSourcesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableSourcesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableSourcesContext) +} + +func (s *MultipleUpdateStatementContext) SET() antlr.TerminalNode { + return s.GetToken(MySqlParserSET, 0) +} + +func (s *MultipleUpdateStatementContext) AllUpdatedElement() []IUpdatedElementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUpdatedElementContext); ok { + len++ + } + } + + tst := make([]IUpdatedElementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUpdatedElementContext); ok { + tst[i] = t.(IUpdatedElementContext) + i++ + } + } + + return tst +} + +func (s *MultipleUpdateStatementContext) UpdatedElement(i int) IUpdatedElementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdatedElementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUpdatedElementContext) +} + +func (s *MultipleUpdateStatementContext) IGNORE() antlr.TerminalNode { + return s.GetToken(MySqlParserIGNORE, 0) +} + +func (s *MultipleUpdateStatementContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *MultipleUpdateStatementContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *MultipleUpdateStatementContext) WHERE() antlr.TerminalNode { + return s.GetToken(MySqlParserWHERE, 0) +} + +func (s *MultipleUpdateStatementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *MultipleUpdateStatementContext) LOW_PRIORITY() antlr.TerminalNode { + return s.GetToken(MySqlParserLOW_PRIORITY, 0) +} + +func (s *MultipleUpdateStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MultipleUpdateStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *MultipleUpdateStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterMultipleUpdateStatement(s) + } +} + +func (s *MultipleUpdateStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitMultipleUpdateStatement(s) + } +} + +func (p *MySqlParser) MultipleUpdateStatement() (localctx IMultipleUpdateStatementContext) { + localctx = NewMultipleUpdateStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 228, MySqlParserRULE_multipleUpdateStatement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3706) + p.Match(MySqlParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3708) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserLOW_PRIORITY { + { + p.SetState(3707) + + var _m = p.Match(MySqlParserLOW_PRIORITY) + + localctx.(*MultipleUpdateStatementContext).priority = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3711) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserIGNORE { + { + p.SetState(3710) + p.Match(MySqlParserIGNORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3713) + p.TableSources() + } + { + p.SetState(3714) + p.Match(MySqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3715) + p.UpdatedElement() + } + p.SetState(3720) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(3716) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3717) + p.UpdatedElement() + } + + p.SetState(3722) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(3725) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserWHERE { + { + p.SetState(3723) + p.Match(MySqlParserWHERE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3724) + p.expression(0) + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOrderByClauseContext is an interface to support dynamic dispatch. +type IOrderByClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ORDER() antlr.TerminalNode + BY() antlr.TerminalNode + AllOrderByExpression() []IOrderByExpressionContext + OrderByExpression(i int) IOrderByExpressionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsOrderByClauseContext differentiates from other interfaces. + IsOrderByClauseContext() +} + +type OrderByClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOrderByClauseContext() *OrderByClauseContext { + var p = new(OrderByClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_orderByClause + return p +} + +func InitEmptyOrderByClauseContext(p *OrderByClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_orderByClause +} + +func (*OrderByClauseContext) IsOrderByClauseContext() {} + +func NewOrderByClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OrderByClauseContext { + var p = new(OrderByClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_orderByClause + + return p +} + +func (s *OrderByClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *OrderByClauseContext) ORDER() antlr.TerminalNode { + return s.GetToken(MySqlParserORDER, 0) +} + +func (s *OrderByClauseContext) BY() antlr.TerminalNode { + return s.GetToken(MySqlParserBY, 0) +} + +func (s *OrderByClauseContext) AllOrderByExpression() []IOrderByExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOrderByExpressionContext); ok { + len++ + } + } + + tst := make([]IOrderByExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOrderByExpressionContext); ok { + tst[i] = t.(IOrderByExpressionContext) + i++ + } + } + + return tst +} + +func (s *OrderByClauseContext) OrderByExpression(i int) IOrderByExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOrderByExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOrderByExpressionContext) +} + +func (s *OrderByClauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *OrderByClauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *OrderByClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *OrderByClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *OrderByClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterOrderByClause(s) + } +} + +func (s *OrderByClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitOrderByClause(s) + } +} + +func (p *MySqlParser) OrderByClause() (localctx IOrderByClauseContext) { + localctx = NewOrderByClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 230, MySqlParserRULE_orderByClause) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3727) + p.Match(MySqlParserORDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3728) + p.Match(MySqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3729) + p.OrderByExpression() + } + p.SetState(3734) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 527, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(3730) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3731) + p.OrderByExpression() + } + + } + p.SetState(3736) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 527, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOrderByExpressionContext is an interface to support dynamic dispatch. +type IOrderByExpressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetOrder returns the order token. + GetOrder() antlr.Token + + // SetOrder sets the order token. + SetOrder(antlr.Token) + + // Getter signatures + Expression() IExpressionContext + ASC() antlr.TerminalNode + DESC() antlr.TerminalNode + + // IsOrderByExpressionContext differentiates from other interfaces. + IsOrderByExpressionContext() +} + +type OrderByExpressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + order antlr.Token +} + +func NewEmptyOrderByExpressionContext() *OrderByExpressionContext { + var p = new(OrderByExpressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_orderByExpression + return p +} + +func InitEmptyOrderByExpressionContext(p *OrderByExpressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_orderByExpression +} + +func (*OrderByExpressionContext) IsOrderByExpressionContext() {} + +func NewOrderByExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OrderByExpressionContext { + var p = new(OrderByExpressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_orderByExpression + + return p +} + +func (s *OrderByExpressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *OrderByExpressionContext) GetOrder() antlr.Token { return s.order } + +func (s *OrderByExpressionContext) SetOrder(v antlr.Token) { s.order = v } + +func (s *OrderByExpressionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *OrderByExpressionContext) ASC() antlr.TerminalNode { + return s.GetToken(MySqlParserASC, 0) +} + +func (s *OrderByExpressionContext) DESC() antlr.TerminalNode { + return s.GetToken(MySqlParserDESC, 0) +} + +func (s *OrderByExpressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *OrderByExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *OrderByExpressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterOrderByExpression(s) + } +} + +func (s *OrderByExpressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitOrderByExpression(s) + } +} + +func (p *MySqlParser) OrderByExpression() (localctx IOrderByExpressionContext) { + localctx = NewOrderByExpressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 232, MySqlParserRULE_orderByExpression) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3737) + p.expression(0) + } + p.SetState(3739) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 528, p.GetParserRuleContext()) == 1 { + { + p.SetState(3738) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*OrderByExpressionContext).order = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserASC || _la == MySqlParserDESC) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*OrderByExpressionContext).order = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITableSourcesContext is an interface to support dynamic dispatch. +type ITableSourcesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllTableSource() []ITableSourceContext + TableSource(i int) ITableSourceContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsTableSourcesContext differentiates from other interfaces. + IsTableSourcesContext() +} + +type TableSourcesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTableSourcesContext() *TableSourcesContext { + var p = new(TableSourcesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_tableSources + return p +} + +func InitEmptyTableSourcesContext(p *TableSourcesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_tableSources +} + +func (*TableSourcesContext) IsTableSourcesContext() {} + +func NewTableSourcesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableSourcesContext { + var p = new(TableSourcesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_tableSources + + return p +} + +func (s *TableSourcesContext) GetParser() antlr.Parser { return s.parser } + +func (s *TableSourcesContext) AllTableSource() []ITableSourceContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITableSourceContext); ok { + len++ + } + } + + tst := make([]ITableSourceContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITableSourceContext); ok { + tst[i] = t.(ITableSourceContext) + i++ + } + } + + return tst +} + +func (s *TableSourcesContext) TableSource(i int) ITableSourceContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableSourceContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITableSourceContext) +} + +func (s *TableSourcesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *TableSourcesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *TableSourcesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableSourcesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TableSourcesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTableSources(s) + } +} + +func (s *TableSourcesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTableSources(s) + } +} + +func (p *MySqlParser) TableSources() (localctx ITableSourcesContext) { + localctx = NewTableSourcesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 234, MySqlParserRULE_tableSources) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3741) + p.TableSource() + } + p.SetState(3746) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 529, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(3742) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3743) + p.TableSource() + } + + } + p.SetState(3748) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 529, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITableSourceContext is an interface to support dynamic dispatch. +type ITableSourceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsTableSourceContext differentiates from other interfaces. + IsTableSourceContext() +} + +type TableSourceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTableSourceContext() *TableSourceContext { + var p = new(TableSourceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_tableSource + return p +} + +func InitEmptyTableSourceContext(p *TableSourceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_tableSource +} + +func (*TableSourceContext) IsTableSourceContext() {} + +func NewTableSourceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableSourceContext { + var p = new(TableSourceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_tableSource + + return p +} + +func (s *TableSourceContext) GetParser() antlr.Parser { return s.parser } + +func (s *TableSourceContext) CopyAll(ctx *TableSourceContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *TableSourceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableSourceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type TableJsonContext struct { + TableSourceContext +} + +func NewTableJsonContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableJsonContext { + var p = new(TableJsonContext) + + InitEmptyTableSourceContext(&p.TableSourceContext) + p.parser = parser + p.CopyAll(ctx.(*TableSourceContext)) + + return p +} + +func (s *TableJsonContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableJsonContext) JsonTable() IJsonTableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJsonTableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJsonTableContext) +} + +func (s *TableJsonContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTableJson(s) + } +} + +func (s *TableJsonContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTableJson(s) + } +} + +type TableSourceNestedContext struct { + TableSourceContext +} + +func NewTableSourceNestedContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableSourceNestedContext { + var p = new(TableSourceNestedContext) + + InitEmptyTableSourceContext(&p.TableSourceContext) + p.parser = parser + p.CopyAll(ctx.(*TableSourceContext)) + + return p +} + +func (s *TableSourceNestedContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableSourceNestedContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *TableSourceNestedContext) TableSourceItem() ITableSourceItemContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableSourceItemContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableSourceItemContext) +} + +func (s *TableSourceNestedContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *TableSourceNestedContext) AllJoinPart() []IJoinPartContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IJoinPartContext); ok { + len++ + } + } + + tst := make([]IJoinPartContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IJoinPartContext); ok { + tst[i] = t.(IJoinPartContext) + i++ + } + } + + return tst +} + +func (s *TableSourceNestedContext) JoinPart(i int) IJoinPartContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJoinPartContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IJoinPartContext) +} + +func (s *TableSourceNestedContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTableSourceNested(s) + } +} + +func (s *TableSourceNestedContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTableSourceNested(s) + } +} + +type TableSourceBaseContext struct { + TableSourceContext +} + +func NewTableSourceBaseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableSourceBaseContext { + var p = new(TableSourceBaseContext) + + InitEmptyTableSourceContext(&p.TableSourceContext) + p.parser = parser + p.CopyAll(ctx.(*TableSourceContext)) + + return p +} + +func (s *TableSourceBaseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableSourceBaseContext) TableSourceItem() ITableSourceItemContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableSourceItemContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableSourceItemContext) +} + +func (s *TableSourceBaseContext) AllJoinPart() []IJoinPartContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IJoinPartContext); ok { + len++ + } + } + + tst := make([]IJoinPartContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IJoinPartContext); ok { + tst[i] = t.(IJoinPartContext) + i++ + } + } + + return tst +} + +func (s *TableSourceBaseContext) JoinPart(i int) IJoinPartContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJoinPartContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IJoinPartContext) +} + +func (s *TableSourceBaseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTableSourceBase(s) + } +} + +func (s *TableSourceBaseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTableSourceBase(s) + } +} + +func (p *MySqlParser) TableSource() (localctx ITableSourceContext) { + localctx = NewTableSourceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 236, MySqlParserRULE_tableSource) + var _la int + + var _alt int + + p.SetState(3767) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 532, p.GetParserRuleContext()) { + case 1: + localctx = NewTableSourceBaseContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3749) + p.TableSourceItem() + } + p.SetState(3753) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 530, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(3750) + p.JoinPart() + } + + } + p.SetState(3755) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 530, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 2: + localctx = NewTableSourceNestedContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3756) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3757) + p.TableSourceItem() + } + p.SetState(3761) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ((int64((_la-34)) & ^0x3f) == 0 && ((int64(1)<<(_la-34))&-9150751492863426559) != 0) || ((int64((_la-113)) & ^0x3f) == 0 && ((int64(1)<<(_la-113))&288230410511450113) != 0) { + { + p.SetState(3758) + p.JoinPart() + } + + p.SetState(3763) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3764) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + localctx = NewTableJsonContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3766) + p.JsonTable() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITableSourceItemContext is an interface to support dynamic dispatch. +type ITableSourceItemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsTableSourceItemContext differentiates from other interfaces. + IsTableSourceItemContext() +} + +type TableSourceItemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTableSourceItemContext() *TableSourceItemContext { + var p = new(TableSourceItemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_tableSourceItem + return p +} + +func InitEmptyTableSourceItemContext(p *TableSourceItemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_tableSourceItem +} + +func (*TableSourceItemContext) IsTableSourceItemContext() {} + +func NewTableSourceItemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableSourceItemContext { + var p = new(TableSourceItemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_tableSourceItem + + return p +} + +func (s *TableSourceItemContext) GetParser() antlr.Parser { return s.parser } + +func (s *TableSourceItemContext) CopyAll(ctx *TableSourceItemContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *TableSourceItemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableSourceItemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type SubqueryTableItemContext struct { + TableSourceItemContext + parenthesisSubquery ISelectStatementContext + alias IUidContext +} + +func NewSubqueryTableItemContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SubqueryTableItemContext { + var p = new(SubqueryTableItemContext) + + InitEmptyTableSourceItemContext(&p.TableSourceItemContext) + p.parser = parser + p.CopyAll(ctx.(*TableSourceItemContext)) + + return p +} + +func (s *SubqueryTableItemContext) GetParenthesisSubquery() ISelectStatementContext { + return s.parenthesisSubquery +} + +func (s *SubqueryTableItemContext) GetAlias() IUidContext { return s.alias } + +func (s *SubqueryTableItemContext) SetParenthesisSubquery(v ISelectStatementContext) { + s.parenthesisSubquery = v +} + +func (s *SubqueryTableItemContext) SetAlias(v IUidContext) { s.alias = v } + +func (s *SubqueryTableItemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SubqueryTableItemContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *SubqueryTableItemContext) SelectStatement() ISelectStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelectStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelectStatementContext) +} + +func (s *SubqueryTableItemContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *SubqueryTableItemContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *SubqueryTableItemContext) AS() antlr.TerminalNode { + return s.GetToken(MySqlParserAS, 0) +} + +func (s *SubqueryTableItemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSubqueryTableItem(s) + } +} + +func (s *SubqueryTableItemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSubqueryTableItem(s) + } +} + +type AtomTableItemContext struct { + TableSourceItemContext + alias IUidContext +} + +func NewAtomTableItemContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AtomTableItemContext { + var p = new(AtomTableItemContext) + + InitEmptyTableSourceItemContext(&p.TableSourceItemContext) + p.parser = parser + p.CopyAll(ctx.(*TableSourceItemContext)) + + return p +} + +func (s *AtomTableItemContext) GetAlias() IUidContext { return s.alias } + +func (s *AtomTableItemContext) SetAlias(v IUidContext) { s.alias = v } + +func (s *AtomTableItemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AtomTableItemContext) TableName() ITableNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableNameContext) +} + +func (s *AtomTableItemContext) PARTITION() antlr.TerminalNode { + return s.GetToken(MySqlParserPARTITION, 0) +} + +func (s *AtomTableItemContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *AtomTableItemContext) UidList() IUidListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidListContext) +} + +func (s *AtomTableItemContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *AtomTableItemContext) AllIndexHint() []IIndexHintContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIndexHintContext); ok { + len++ + } + } + + tst := make([]IIndexHintContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIndexHintContext); ok { + tst[i] = t.(IIndexHintContext) + i++ + } + } + + return tst +} + +func (s *AtomTableItemContext) IndexHint(i int) IIndexHintContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexHintContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIndexHintContext) +} + +func (s *AtomTableItemContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *AtomTableItemContext) AS() antlr.TerminalNode { + return s.GetToken(MySqlParserAS, 0) +} + +func (s *AtomTableItemContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *AtomTableItemContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *AtomTableItemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAtomTableItem(s) + } +} + +func (s *AtomTableItemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAtomTableItem(s) + } +} + +type TableSourcesItemContext struct { + TableSourceItemContext +} + +func NewTableSourcesItemContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableSourcesItemContext { + var p = new(TableSourcesItemContext) + + InitEmptyTableSourceItemContext(&p.TableSourceItemContext) + p.parser = parser + p.CopyAll(ctx.(*TableSourceItemContext)) + + return p +} + +func (s *TableSourcesItemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableSourcesItemContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *TableSourcesItemContext) TableSources() ITableSourcesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableSourcesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableSourcesContext) +} + +func (s *TableSourcesItemContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *TableSourcesItemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTableSourcesItem(s) + } +} + +func (s *TableSourcesItemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTableSourcesItem(s) + } +} + +func (p *MySqlParser) TableSourceItem() (localctx ITableSourceItemContext) { + localctx = NewTableSourceItemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 238, MySqlParserRULE_tableSourceItem) + var _la int + + var _alt int + + p.SetState(3809) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 540, p.GetParserRuleContext()) { + case 1: + localctx = NewAtomTableItemContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3769) + p.TableName() + } + p.SetState(3775) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserPARTITION { + { + p.SetState(3770) + p.Match(MySqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3771) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3772) + p.UidList() + } + { + p.SetState(3773) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3781) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 535, p.GetParserRuleContext()) == 1 { + p.SetState(3778) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserAS { + { + p.SetState(3777) + p.Match(MySqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3780) + + var _x = p.Uid() + + localctx.(*AtomTableItemContext).alias = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3791) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 537, p.GetParserRuleContext()) == 1 { + { + p.SetState(3783) + p.IndexHint() + } + p.SetState(3788) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 536, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(3784) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3785) + p.IndexHint() + } + + } + p.SetState(3790) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 536, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + localctx = NewSubqueryTableItemContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + p.SetState(3798) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 538, p.GetParserRuleContext()) { + case 1: + { + p.SetState(3793) + p.SelectStatement() + } + + case 2: + { + p.SetState(3794) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3795) + + var _x = p.SelectStatement() + + localctx.(*SubqueryTableItemContext).parenthesisSubquery = _x + } + { + p.SetState(3796) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(3801) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserAS { + { + p.SetState(3800) + p.Match(MySqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3803) + + var _x = p.Uid() + + localctx.(*SubqueryTableItemContext).alias = _x + } + + case 3: + localctx = NewTableSourcesItemContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3805) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3806) + p.TableSources() + } + { + p.SetState(3807) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndexHintContext is an interface to support dynamic dispatch. +type IIndexHintContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetIndexHintAction returns the indexHintAction token. + GetIndexHintAction() antlr.Token + + // GetKeyFormat returns the keyFormat token. + GetKeyFormat() antlr.Token + + // SetIndexHintAction sets the indexHintAction token. + SetIndexHintAction(antlr.Token) + + // SetKeyFormat sets the keyFormat token. + SetKeyFormat(antlr.Token) + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + UidList() IUidListContext + RR_BRACKET() antlr.TerminalNode + USE() antlr.TerminalNode + IGNORE() antlr.TerminalNode + FORCE() antlr.TerminalNode + INDEX() antlr.TerminalNode + KEY() antlr.TerminalNode + FOR() antlr.TerminalNode + IndexHintType() IIndexHintTypeContext + + // IsIndexHintContext differentiates from other interfaces. + IsIndexHintContext() +} + +type IndexHintContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + indexHintAction antlr.Token + keyFormat antlr.Token +} + +func NewEmptyIndexHintContext() *IndexHintContext { + var p = new(IndexHintContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_indexHint + return p +} + +func InitEmptyIndexHintContext(p *IndexHintContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_indexHint +} + +func (*IndexHintContext) IsIndexHintContext() {} + +func NewIndexHintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndexHintContext { + var p = new(IndexHintContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_indexHint + + return p +} + +func (s *IndexHintContext) GetParser() antlr.Parser { return s.parser } + +func (s *IndexHintContext) GetIndexHintAction() antlr.Token { return s.indexHintAction } + +func (s *IndexHintContext) GetKeyFormat() antlr.Token { return s.keyFormat } + +func (s *IndexHintContext) SetIndexHintAction(v antlr.Token) { s.indexHintAction = v } + +func (s *IndexHintContext) SetKeyFormat(v antlr.Token) { s.keyFormat = v } + +func (s *IndexHintContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *IndexHintContext) UidList() IUidListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidListContext) +} + +func (s *IndexHintContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *IndexHintContext) USE() antlr.TerminalNode { + return s.GetToken(MySqlParserUSE, 0) +} + +func (s *IndexHintContext) IGNORE() antlr.TerminalNode { + return s.GetToken(MySqlParserIGNORE, 0) +} + +func (s *IndexHintContext) FORCE() antlr.TerminalNode { + return s.GetToken(MySqlParserFORCE, 0) +} + +func (s *IndexHintContext) INDEX() antlr.TerminalNode { + return s.GetToken(MySqlParserINDEX, 0) +} + +func (s *IndexHintContext) KEY() antlr.TerminalNode { + return s.GetToken(MySqlParserKEY, 0) +} + +func (s *IndexHintContext) FOR() antlr.TerminalNode { + return s.GetToken(MySqlParserFOR, 0) +} + +func (s *IndexHintContext) IndexHintType() IIndexHintTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexHintTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndexHintTypeContext) +} + +func (s *IndexHintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IndexHintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IndexHintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterIndexHint(s) + } +} + +func (s *IndexHintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitIndexHint(s) + } +} + +func (p *MySqlParser) IndexHint() (localctx IIndexHintContext) { + localctx = NewIndexHintContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 240, MySqlParserRULE_indexHint) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3811) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*IndexHintContext).indexHintAction = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserFORCE || _la == MySqlParserIGNORE || _la == MySqlParserUSE) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*IndexHintContext).indexHintAction = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(3812) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*IndexHintContext).keyFormat = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserINDEX || _la == MySqlParserKEY) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*IndexHintContext).keyFormat = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(3815) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserFOR { + { + p.SetState(3813) + p.Match(MySqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3814) + p.IndexHintType() + } + + } + { + p.SetState(3817) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3818) + p.UidList() + } + { + p.SetState(3819) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndexHintTypeContext is an interface to support dynamic dispatch. +type IIndexHintTypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + JOIN() antlr.TerminalNode + ORDER() antlr.TerminalNode + BY() antlr.TerminalNode + GROUP() antlr.TerminalNode + + // IsIndexHintTypeContext differentiates from other interfaces. + IsIndexHintTypeContext() +} + +type IndexHintTypeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndexHintTypeContext() *IndexHintTypeContext { + var p = new(IndexHintTypeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_indexHintType + return p +} + +func InitEmptyIndexHintTypeContext(p *IndexHintTypeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_indexHintType +} + +func (*IndexHintTypeContext) IsIndexHintTypeContext() {} + +func NewIndexHintTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndexHintTypeContext { + var p = new(IndexHintTypeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_indexHintType + + return p +} + +func (s *IndexHintTypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *IndexHintTypeContext) JOIN() antlr.TerminalNode { + return s.GetToken(MySqlParserJOIN, 0) +} + +func (s *IndexHintTypeContext) ORDER() antlr.TerminalNode { + return s.GetToken(MySqlParserORDER, 0) +} + +func (s *IndexHintTypeContext) BY() antlr.TerminalNode { + return s.GetToken(MySqlParserBY, 0) +} + +func (s *IndexHintTypeContext) GROUP() antlr.TerminalNode { + return s.GetToken(MySqlParserGROUP, 0) +} + +func (s *IndexHintTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IndexHintTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IndexHintTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterIndexHintType(s) + } +} + +func (s *IndexHintTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitIndexHintType(s) + } +} + +func (p *MySqlParser) IndexHintType() (localctx IIndexHintTypeContext) { + localctx = NewIndexHintTypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 242, MySqlParserRULE_indexHintType) + p.SetState(3826) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserJOIN: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3821) + p.Match(MySqlParserJOIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserORDER: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3822) + p.Match(MySqlParserORDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3823) + p.Match(MySqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserGROUP: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3824) + p.Match(MySqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3825) + p.Match(MySqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJoinPartContext is an interface to support dynamic dispatch. +type IJoinPartContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsJoinPartContext differentiates from other interfaces. + IsJoinPartContext() +} + +type JoinPartContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJoinPartContext() *JoinPartContext { + var p = new(JoinPartContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_joinPart + return p +} + +func InitEmptyJoinPartContext(p *JoinPartContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_joinPart +} + +func (*JoinPartContext) IsJoinPartContext() {} + +func NewJoinPartContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *JoinPartContext { + var p = new(JoinPartContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_joinPart + + return p +} + +func (s *JoinPartContext) GetParser() antlr.Parser { return s.parser } + +func (s *JoinPartContext) CopyAll(ctx *JoinPartContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *JoinPartContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *JoinPartContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type InnerJoinContext struct { + JoinPartContext +} + +func NewInnerJoinContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *InnerJoinContext { + var p = new(InnerJoinContext) + + InitEmptyJoinPartContext(&p.JoinPartContext) + p.parser = parser + p.CopyAll(ctx.(*JoinPartContext)) + + return p +} + +func (s *InnerJoinContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *InnerJoinContext) JOIN() antlr.TerminalNode { + return s.GetToken(MySqlParserJOIN, 0) +} + +func (s *InnerJoinContext) TableSourceItem() ITableSourceItemContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableSourceItemContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableSourceItemContext) +} + +func (s *InnerJoinContext) LATERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserLATERAL, 0) +} + +func (s *InnerJoinContext) AllJoinSpec() []IJoinSpecContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IJoinSpecContext); ok { + len++ + } + } + + tst := make([]IJoinSpecContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IJoinSpecContext); ok { + tst[i] = t.(IJoinSpecContext) + i++ + } + } + + return tst +} + +func (s *InnerJoinContext) JoinSpec(i int) IJoinSpecContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJoinSpecContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IJoinSpecContext) +} + +func (s *InnerJoinContext) INNER() antlr.TerminalNode { + return s.GetToken(MySqlParserINNER, 0) +} + +func (s *InnerJoinContext) CROSS() antlr.TerminalNode { + return s.GetToken(MySqlParserCROSS, 0) +} + +func (s *InnerJoinContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterInnerJoin(s) + } +} + +func (s *InnerJoinContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitInnerJoin(s) + } +} + +type NaturalJoinContext struct { + JoinPartContext +} + +func NewNaturalJoinContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NaturalJoinContext { + var p = new(NaturalJoinContext) + + InitEmptyJoinPartContext(&p.JoinPartContext) + p.parser = parser + p.CopyAll(ctx.(*JoinPartContext)) + + return p +} + +func (s *NaturalJoinContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *NaturalJoinContext) NATURAL() antlr.TerminalNode { + return s.GetToken(MySqlParserNATURAL, 0) +} + +func (s *NaturalJoinContext) JOIN() antlr.TerminalNode { + return s.GetToken(MySqlParserJOIN, 0) +} + +func (s *NaturalJoinContext) TableSourceItem() ITableSourceItemContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableSourceItemContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableSourceItemContext) +} + +func (s *NaturalJoinContext) LEFT() antlr.TerminalNode { + return s.GetToken(MySqlParserLEFT, 0) +} + +func (s *NaturalJoinContext) RIGHT() antlr.TerminalNode { + return s.GetToken(MySqlParserRIGHT, 0) +} + +func (s *NaturalJoinContext) OUTER() antlr.TerminalNode { + return s.GetToken(MySqlParserOUTER, 0) +} + +func (s *NaturalJoinContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterNaturalJoin(s) + } +} + +func (s *NaturalJoinContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitNaturalJoin(s) + } +} + +type OuterJoinContext struct { + JoinPartContext +} + +func NewOuterJoinContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *OuterJoinContext { + var p = new(OuterJoinContext) + + InitEmptyJoinPartContext(&p.JoinPartContext) + p.parser = parser + p.CopyAll(ctx.(*JoinPartContext)) + + return p +} + +func (s *OuterJoinContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *OuterJoinContext) JOIN() antlr.TerminalNode { + return s.GetToken(MySqlParserJOIN, 0) +} + +func (s *OuterJoinContext) TableSourceItem() ITableSourceItemContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableSourceItemContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableSourceItemContext) +} + +func (s *OuterJoinContext) LEFT() antlr.TerminalNode { + return s.GetToken(MySqlParserLEFT, 0) +} + +func (s *OuterJoinContext) RIGHT() antlr.TerminalNode { + return s.GetToken(MySqlParserRIGHT, 0) +} + +func (s *OuterJoinContext) OUTER() antlr.TerminalNode { + return s.GetToken(MySqlParserOUTER, 0) +} + +func (s *OuterJoinContext) LATERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserLATERAL, 0) +} + +func (s *OuterJoinContext) AllJoinSpec() []IJoinSpecContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IJoinSpecContext); ok { + len++ + } + } + + tst := make([]IJoinSpecContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IJoinSpecContext); ok { + tst[i] = t.(IJoinSpecContext) + i++ + } + } + + return tst +} + +func (s *OuterJoinContext) JoinSpec(i int) IJoinSpecContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJoinSpecContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IJoinSpecContext) +} + +func (s *OuterJoinContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterOuterJoin(s) + } +} + +func (s *OuterJoinContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitOuterJoin(s) + } +} + +type StraightJoinContext struct { + JoinPartContext +} + +func NewStraightJoinContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StraightJoinContext { + var p = new(StraightJoinContext) + + InitEmptyJoinPartContext(&p.JoinPartContext) + p.parser = parser + p.CopyAll(ctx.(*JoinPartContext)) + + return p +} + +func (s *StraightJoinContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *StraightJoinContext) STRAIGHT_JOIN() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRAIGHT_JOIN, 0) +} + +func (s *StraightJoinContext) TableSourceItem() ITableSourceItemContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableSourceItemContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableSourceItemContext) +} + +func (s *StraightJoinContext) AllON() []antlr.TerminalNode { + return s.GetTokens(MySqlParserON) +} + +func (s *StraightJoinContext) ON(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserON, i) +} + +func (s *StraightJoinContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *StraightJoinContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *StraightJoinContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterStraightJoin(s) + } +} + +func (s *StraightJoinContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitStraightJoin(s) + } +} + +func (p *MySqlParser) JoinPart() (localctx IJoinPartContext) { + localctx = NewJoinPartContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 244, MySqlParserRULE_joinPart) + var _la int + + var _alt int + + p.SetState(3875) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserCROSS, MySqlParserINNER, MySqlParserJOIN: + localctx = NewInnerJoinContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + p.SetState(3829) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserCROSS || _la == MySqlParserINNER { + { + p.SetState(3828) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserCROSS || _la == MySqlParserINNER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(3831) + p.Match(MySqlParserJOIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3833) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 544, p.GetParserRuleContext()) == 1 { + { + p.SetState(3832) + p.Match(MySqlParserLATERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3835) + p.TableSourceItem() + } + p.SetState(3839) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 545, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(3836) + p.JoinSpec() + } + + } + p.SetState(3841) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 545, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case MySqlParserSTRAIGHT_JOIN: + localctx = NewStraightJoinContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3842) + p.Match(MySqlParserSTRAIGHT_JOIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3843) + p.TableSourceItem() + } + p.SetState(3848) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 546, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(3844) + p.Match(MySqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3845) + p.expression(0) + } + + } + p.SetState(3850) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 546, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case MySqlParserLEFT, MySqlParserRIGHT: + localctx = NewOuterJoinContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3851) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserLEFT || _la == MySqlParserRIGHT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(3853) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserOUTER { + { + p.SetState(3852) + p.Match(MySqlParserOUTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3855) + p.Match(MySqlParserJOIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3857) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 548, p.GetParserRuleContext()) == 1 { + { + p.SetState(3856) + p.Match(MySqlParserLATERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3859) + p.TableSourceItem() + } + p.SetState(3863) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 549, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(3860) + p.JoinSpec() + } + + } + p.SetState(3865) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 549, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case MySqlParserNATURAL: + localctx = NewNaturalJoinContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3866) + p.Match(MySqlParserNATURAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3871) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserLEFT || _la == MySqlParserRIGHT { + { + p.SetState(3867) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserLEFT || _la == MySqlParserRIGHT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(3869) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserOUTER { + { + p.SetState(3868) + p.Match(MySqlParserOUTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } + { + p.SetState(3873) + p.Match(MySqlParserJOIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3874) + p.TableSourceItem() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJoinSpecContext is an interface to support dynamic dispatch. +type IJoinSpecContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ON() antlr.TerminalNode + Expression() IExpressionContext + USING() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + UidList() IUidListContext + RR_BRACKET() antlr.TerminalNode + + // IsJoinSpecContext differentiates from other interfaces. + IsJoinSpecContext() +} + +type JoinSpecContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJoinSpecContext() *JoinSpecContext { + var p = new(JoinSpecContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_joinSpec + return p +} + +func InitEmptyJoinSpecContext(p *JoinSpecContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_joinSpec +} + +func (*JoinSpecContext) IsJoinSpecContext() {} + +func NewJoinSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *JoinSpecContext { + var p = new(JoinSpecContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_joinSpec + + return p +} + +func (s *JoinSpecContext) GetParser() antlr.Parser { return s.parser } + +func (s *JoinSpecContext) ON() antlr.TerminalNode { + return s.GetToken(MySqlParserON, 0) +} + +func (s *JoinSpecContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *JoinSpecContext) USING() antlr.TerminalNode { + return s.GetToken(MySqlParserUSING, 0) +} + +func (s *JoinSpecContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *JoinSpecContext) UidList() IUidListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidListContext) +} + +func (s *JoinSpecContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *JoinSpecContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *JoinSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *JoinSpecContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterJoinSpec(s) + } +} + +func (s *JoinSpecContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitJoinSpec(s) + } +} + +func (p *MySqlParser) JoinSpec() (localctx IJoinSpecContext) { + localctx = NewJoinSpecContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 246, MySqlParserRULE_joinSpec) + p.SetState(3884) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserON: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3877) + p.Match(MySqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3878) + p.expression(0) + } + + case MySqlParserUSING: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3879) + p.Match(MySqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3880) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3881) + p.UidList() + } + { + p.SetState(3882) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQueryExpressionContext is an interface to support dynamic dispatch. +type IQueryExpressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + QuerySpecification() IQuerySpecificationContext + RR_BRACKET() antlr.TerminalNode + QueryExpression() IQueryExpressionContext + + // IsQueryExpressionContext differentiates from other interfaces. + IsQueryExpressionContext() +} + +type QueryExpressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQueryExpressionContext() *QueryExpressionContext { + var p = new(QueryExpressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_queryExpression + return p +} + +func InitEmptyQueryExpressionContext(p *QueryExpressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_queryExpression +} + +func (*QueryExpressionContext) IsQueryExpressionContext() {} + +func NewQueryExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *QueryExpressionContext { + var p = new(QueryExpressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_queryExpression + + return p +} + +func (s *QueryExpressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *QueryExpressionContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *QueryExpressionContext) QuerySpecification() IQuerySpecificationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuerySpecificationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuerySpecificationContext) +} + +func (s *QueryExpressionContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *QueryExpressionContext) QueryExpression() IQueryExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQueryExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQueryExpressionContext) +} + +func (s *QueryExpressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *QueryExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *QueryExpressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterQueryExpression(s) + } +} + +func (s *QueryExpressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitQueryExpression(s) + } +} + +func (p *MySqlParser) QueryExpression() (localctx IQueryExpressionContext) { + localctx = NewQueryExpressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 248, MySqlParserRULE_queryExpression) + p.SetState(3894) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 554, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3886) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3887) + p.QuerySpecification() + } + { + p.SetState(3888) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3890) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3891) + p.QueryExpression() + } + { + p.SetState(3892) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQueryExpressionNointoContext is an interface to support dynamic dispatch. +type IQueryExpressionNointoContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + QuerySpecificationNointo() IQuerySpecificationNointoContext + RR_BRACKET() antlr.TerminalNode + QueryExpressionNointo() IQueryExpressionNointoContext + + // IsQueryExpressionNointoContext differentiates from other interfaces. + IsQueryExpressionNointoContext() +} + +type QueryExpressionNointoContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQueryExpressionNointoContext() *QueryExpressionNointoContext { + var p = new(QueryExpressionNointoContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_queryExpressionNointo + return p +} + +func InitEmptyQueryExpressionNointoContext(p *QueryExpressionNointoContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_queryExpressionNointo +} + +func (*QueryExpressionNointoContext) IsQueryExpressionNointoContext() {} + +func NewQueryExpressionNointoContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *QueryExpressionNointoContext { + var p = new(QueryExpressionNointoContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_queryExpressionNointo + + return p +} + +func (s *QueryExpressionNointoContext) GetParser() antlr.Parser { return s.parser } + +func (s *QueryExpressionNointoContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *QueryExpressionNointoContext) QuerySpecificationNointo() IQuerySpecificationNointoContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuerySpecificationNointoContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuerySpecificationNointoContext) +} + +func (s *QueryExpressionNointoContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *QueryExpressionNointoContext) QueryExpressionNointo() IQueryExpressionNointoContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQueryExpressionNointoContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQueryExpressionNointoContext) +} + +func (s *QueryExpressionNointoContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *QueryExpressionNointoContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *QueryExpressionNointoContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterQueryExpressionNointo(s) + } +} + +func (s *QueryExpressionNointoContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitQueryExpressionNointo(s) + } +} + +func (p *MySqlParser) QueryExpressionNointo() (localctx IQueryExpressionNointoContext) { + localctx = NewQueryExpressionNointoContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 250, MySqlParserRULE_queryExpressionNointo) + p.SetState(3904) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 555, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3896) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3897) + p.QuerySpecificationNointo() + } + { + p.SetState(3898) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3900) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3901) + p.QueryExpressionNointo() + } + { + p.SetState(3902) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQuerySpecificationContext is an interface to support dynamic dispatch. +type IQuerySpecificationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SELECT() antlr.TerminalNode + SelectElements() ISelectElementsContext + FromClause() IFromClauseContext + AllSelectSpec() []ISelectSpecContext + SelectSpec(i int) ISelectSpecContext + SelectIntoExpression() ISelectIntoExpressionContext + GroupByClause() IGroupByClauseContext + HavingClause() IHavingClauseContext + WindowClause() IWindowClauseContext + OrderByClause() IOrderByClauseContext + LimitClause() ILimitClauseContext + + // IsQuerySpecificationContext differentiates from other interfaces. + IsQuerySpecificationContext() +} + +type QuerySpecificationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQuerySpecificationContext() *QuerySpecificationContext { + var p = new(QuerySpecificationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_querySpecification + return p +} + +func InitEmptyQuerySpecificationContext(p *QuerySpecificationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_querySpecification +} + +func (*QuerySpecificationContext) IsQuerySpecificationContext() {} + +func NewQuerySpecificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *QuerySpecificationContext { + var p = new(QuerySpecificationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_querySpecification + + return p +} + +func (s *QuerySpecificationContext) GetParser() antlr.Parser { return s.parser } + +func (s *QuerySpecificationContext) SELECT() antlr.TerminalNode { + return s.GetToken(MySqlParserSELECT, 0) +} + +func (s *QuerySpecificationContext) SelectElements() ISelectElementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelectElementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelectElementsContext) +} + +func (s *QuerySpecificationContext) FromClause() IFromClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFromClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFromClauseContext) +} + +func (s *QuerySpecificationContext) AllSelectSpec() []ISelectSpecContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISelectSpecContext); ok { + len++ + } + } + + tst := make([]ISelectSpecContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISelectSpecContext); ok { + tst[i] = t.(ISelectSpecContext) + i++ + } + } + + return tst +} + +func (s *QuerySpecificationContext) SelectSpec(i int) ISelectSpecContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelectSpecContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISelectSpecContext) +} + +func (s *QuerySpecificationContext) SelectIntoExpression() ISelectIntoExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelectIntoExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelectIntoExpressionContext) +} + +func (s *QuerySpecificationContext) GroupByClause() IGroupByClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGroupByClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGroupByClauseContext) +} + +func (s *QuerySpecificationContext) HavingClause() IHavingClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHavingClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHavingClauseContext) +} + +func (s *QuerySpecificationContext) WindowClause() IWindowClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWindowClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWindowClauseContext) +} + +func (s *QuerySpecificationContext) OrderByClause() IOrderByClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOrderByClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOrderByClauseContext) +} + +func (s *QuerySpecificationContext) LimitClause() ILimitClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILimitClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILimitClauseContext) +} + +func (s *QuerySpecificationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *QuerySpecificationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *QuerySpecificationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterQuerySpecification(s) + } +} + +func (s *QuerySpecificationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitQuerySpecification(s) + } +} + +func (p *MySqlParser) QuerySpecification() (localctx IQuerySpecificationContext) { + localctx = NewQuerySpecificationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 252, MySqlParserRULE_querySpecification) + var _la int + + var _alt int + + p.SetState(3960) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 570, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3906) + p.Match(MySqlParserSELECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3910) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 556, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(3907) + p.SelectSpec() + } + + } + p.SetState(3912) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 556, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + { + p.SetState(3913) + p.SelectElements() + } + p.SetState(3915) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserINTO { + { + p.SetState(3914) + p.SelectIntoExpression() + } + + } + { + p.SetState(3917) + p.FromClause() + } + p.SetState(3919) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 558, p.GetParserRuleContext()) == 1 { + { + p.SetState(3918) + p.GroupByClause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3922) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserHAVING { + { + p.SetState(3921) + p.HavingClause() + } + + } + p.SetState(3925) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserWINDOW { + { + p.SetState(3924) + p.WindowClause() + } + + } + p.SetState(3928) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 561, p.GetParserRuleContext()) == 1 { + { + p.SetState(3927) + p.OrderByClause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3931) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 562, p.GetParserRuleContext()) == 1 { + { + p.SetState(3930) + p.LimitClause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3933) + p.Match(MySqlParserSELECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3937) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 563, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(3934) + p.SelectSpec() + } + + } + p.SetState(3939) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 563, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + { + p.SetState(3940) + p.SelectElements() + } + { + p.SetState(3941) + p.FromClause() + } + p.SetState(3943) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 564, p.GetParserRuleContext()) == 1 { + { + p.SetState(3942) + p.GroupByClause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3946) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserHAVING { + { + p.SetState(3945) + p.HavingClause() + } + + } + p.SetState(3949) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserWINDOW { + { + p.SetState(3948) + p.WindowClause() + } + + } + p.SetState(3952) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 567, p.GetParserRuleContext()) == 1 { + { + p.SetState(3951) + p.OrderByClause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3955) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 568, p.GetParserRuleContext()) == 1 { + { + p.SetState(3954) + p.LimitClause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3958) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserINTO { + { + p.SetState(3957) + p.SelectIntoExpression() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQuerySpecificationNointoContext is an interface to support dynamic dispatch. +type IQuerySpecificationNointoContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SELECT() antlr.TerminalNode + SelectElements() ISelectElementsContext + FromClause() IFromClauseContext + AllSelectSpec() []ISelectSpecContext + SelectSpec(i int) ISelectSpecContext + GroupByClause() IGroupByClauseContext + HavingClause() IHavingClauseContext + WindowClause() IWindowClauseContext + OrderByClause() IOrderByClauseContext + LimitClause() ILimitClauseContext + UnionStatement() IUnionStatementContext + + // IsQuerySpecificationNointoContext differentiates from other interfaces. + IsQuerySpecificationNointoContext() +} + +type QuerySpecificationNointoContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQuerySpecificationNointoContext() *QuerySpecificationNointoContext { + var p = new(QuerySpecificationNointoContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_querySpecificationNointo + return p +} + +func InitEmptyQuerySpecificationNointoContext(p *QuerySpecificationNointoContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_querySpecificationNointo +} + +func (*QuerySpecificationNointoContext) IsQuerySpecificationNointoContext() {} + +func NewQuerySpecificationNointoContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *QuerySpecificationNointoContext { + var p = new(QuerySpecificationNointoContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_querySpecificationNointo + + return p +} + +func (s *QuerySpecificationNointoContext) GetParser() antlr.Parser { return s.parser } + +func (s *QuerySpecificationNointoContext) SELECT() antlr.TerminalNode { + return s.GetToken(MySqlParserSELECT, 0) +} + +func (s *QuerySpecificationNointoContext) SelectElements() ISelectElementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelectElementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelectElementsContext) +} + +func (s *QuerySpecificationNointoContext) FromClause() IFromClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFromClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFromClauseContext) +} + +func (s *QuerySpecificationNointoContext) AllSelectSpec() []ISelectSpecContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISelectSpecContext); ok { + len++ + } + } + + tst := make([]ISelectSpecContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISelectSpecContext); ok { + tst[i] = t.(ISelectSpecContext) + i++ + } + } + + return tst +} + +func (s *QuerySpecificationNointoContext) SelectSpec(i int) ISelectSpecContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelectSpecContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISelectSpecContext) +} + +func (s *QuerySpecificationNointoContext) GroupByClause() IGroupByClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGroupByClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGroupByClauseContext) +} + +func (s *QuerySpecificationNointoContext) HavingClause() IHavingClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHavingClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHavingClauseContext) +} + +func (s *QuerySpecificationNointoContext) WindowClause() IWindowClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWindowClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWindowClauseContext) +} + +func (s *QuerySpecificationNointoContext) OrderByClause() IOrderByClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOrderByClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOrderByClauseContext) +} + +func (s *QuerySpecificationNointoContext) LimitClause() ILimitClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILimitClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILimitClauseContext) +} + +func (s *QuerySpecificationNointoContext) UnionStatement() IUnionStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnionStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnionStatementContext) +} + +func (s *QuerySpecificationNointoContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *QuerySpecificationNointoContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *QuerySpecificationNointoContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterQuerySpecificationNointo(s) + } +} + +func (s *QuerySpecificationNointoContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitQuerySpecificationNointo(s) + } +} + +func (p *MySqlParser) QuerySpecificationNointo() (localctx IQuerySpecificationNointoContext) { + localctx = NewQuerySpecificationNointoContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 254, MySqlParserRULE_querySpecificationNointo) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3962) + p.Match(MySqlParserSELECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3966) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 571, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(3963) + p.SelectSpec() + } + + } + p.SetState(3968) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 571, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + { + p.SetState(3969) + p.SelectElements() + } + { + p.SetState(3970) + p.FromClause() + } + p.SetState(3972) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 572, p.GetParserRuleContext()) == 1 { + { + p.SetState(3971) + p.GroupByClause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3975) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserHAVING { + { + p.SetState(3974) + p.HavingClause() + } + + } + p.SetState(3978) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserWINDOW { + { + p.SetState(3977) + p.WindowClause() + } + + } + p.SetState(3981) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 575, p.GetParserRuleContext()) == 1 { + { + p.SetState(3980) + p.OrderByClause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3984) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 576, p.GetParserRuleContext()) == 1 { + { + p.SetState(3983) + p.LimitClause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3987) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 577, p.GetParserRuleContext()) == 1 { + { + p.SetState(3986) + p.UnionStatement() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUnionParenthesisContext is an interface to support dynamic dispatch. +type IUnionParenthesisContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetUnionType returns the unionType token. + GetUnionType() antlr.Token + + // SetUnionType sets the unionType token. + SetUnionType(antlr.Token) + + // Getter signatures + UNION() antlr.TerminalNode + QueryExpressionNointo() IQueryExpressionNointoContext + ALL() antlr.TerminalNode + DISTINCT() antlr.TerminalNode + + // IsUnionParenthesisContext differentiates from other interfaces. + IsUnionParenthesisContext() +} + +type UnionParenthesisContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + unionType antlr.Token +} + +func NewEmptyUnionParenthesisContext() *UnionParenthesisContext { + var p = new(UnionParenthesisContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_unionParenthesis + return p +} + +func InitEmptyUnionParenthesisContext(p *UnionParenthesisContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_unionParenthesis +} + +func (*UnionParenthesisContext) IsUnionParenthesisContext() {} + +func NewUnionParenthesisContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnionParenthesisContext { + var p = new(UnionParenthesisContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_unionParenthesis + + return p +} + +func (s *UnionParenthesisContext) GetParser() antlr.Parser { return s.parser } + +func (s *UnionParenthesisContext) GetUnionType() antlr.Token { return s.unionType } + +func (s *UnionParenthesisContext) SetUnionType(v antlr.Token) { s.unionType = v } + +func (s *UnionParenthesisContext) UNION() antlr.TerminalNode { + return s.GetToken(MySqlParserUNION, 0) +} + +func (s *UnionParenthesisContext) QueryExpressionNointo() IQueryExpressionNointoContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQueryExpressionNointoContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQueryExpressionNointoContext) +} + +func (s *UnionParenthesisContext) ALL() antlr.TerminalNode { + return s.GetToken(MySqlParserALL, 0) +} + +func (s *UnionParenthesisContext) DISTINCT() antlr.TerminalNode { + return s.GetToken(MySqlParserDISTINCT, 0) +} + +func (s *UnionParenthesisContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UnionParenthesisContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *UnionParenthesisContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterUnionParenthesis(s) + } +} + +func (s *UnionParenthesisContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitUnionParenthesis(s) + } +} + +func (p *MySqlParser) UnionParenthesis() (localctx IUnionParenthesisContext) { + localctx = NewUnionParenthesisContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 256, MySqlParserRULE_unionParenthesis) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3989) + p.Match(MySqlParserUNION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3991) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserALL || _la == MySqlParserDISTINCT { + { + p.SetState(3990) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*UnionParenthesisContext).unionType = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserALL || _la == MySqlParserDISTINCT) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*UnionParenthesisContext).unionType = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(3993) + p.QueryExpressionNointo() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUnionStatementContext is an interface to support dynamic dispatch. +type IUnionStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetUnionType returns the unionType token. + GetUnionType() antlr.Token + + // SetUnionType sets the unionType token. + SetUnionType(antlr.Token) + + // Getter signatures + UNION() antlr.TerminalNode + QuerySpecificationNointo() IQuerySpecificationNointoContext + QueryExpressionNointo() IQueryExpressionNointoContext + ALL() antlr.TerminalNode + DISTINCT() antlr.TerminalNode + + // IsUnionStatementContext differentiates from other interfaces. + IsUnionStatementContext() +} + +type UnionStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + unionType antlr.Token +} + +func NewEmptyUnionStatementContext() *UnionStatementContext { + var p = new(UnionStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_unionStatement + return p +} + +func InitEmptyUnionStatementContext(p *UnionStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_unionStatement +} + +func (*UnionStatementContext) IsUnionStatementContext() {} + +func NewUnionStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnionStatementContext { + var p = new(UnionStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_unionStatement + + return p +} + +func (s *UnionStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *UnionStatementContext) GetUnionType() antlr.Token { return s.unionType } + +func (s *UnionStatementContext) SetUnionType(v antlr.Token) { s.unionType = v } + +func (s *UnionStatementContext) UNION() antlr.TerminalNode { + return s.GetToken(MySqlParserUNION, 0) +} + +func (s *UnionStatementContext) QuerySpecificationNointo() IQuerySpecificationNointoContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuerySpecificationNointoContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuerySpecificationNointoContext) +} + +func (s *UnionStatementContext) QueryExpressionNointo() IQueryExpressionNointoContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQueryExpressionNointoContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQueryExpressionNointoContext) +} + +func (s *UnionStatementContext) ALL() antlr.TerminalNode { + return s.GetToken(MySqlParserALL, 0) +} + +func (s *UnionStatementContext) DISTINCT() antlr.TerminalNode { + return s.GetToken(MySqlParserDISTINCT, 0) +} + +func (s *UnionStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UnionStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *UnionStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterUnionStatement(s) + } +} + +func (s *UnionStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitUnionStatement(s) + } +} + +func (p *MySqlParser) UnionStatement() (localctx IUnionStatementContext) { + localctx = NewUnionStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 258, MySqlParserRULE_unionStatement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3995) + p.Match(MySqlParserUNION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3997) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserALL || _la == MySqlParserDISTINCT { + { + p.SetState(3996) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*UnionStatementContext).unionType = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserALL || _la == MySqlParserDISTINCT) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*UnionStatementContext).unionType = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(4001) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserSELECT: + { + p.SetState(3999) + p.QuerySpecificationNointo() + } + + case MySqlParserLR_BRACKET: + { + p.SetState(4000) + p.QueryExpressionNointo() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILateralStatementContext is an interface to support dynamic dispatch. +type ILateralStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LATERAL() antlr.TerminalNode + QuerySpecificationNointo() IQuerySpecificationNointoContext + QueryExpressionNointo() IQueryExpressionNointoContext + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + Uid() IUidContext + AS() antlr.TerminalNode + + // IsLateralStatementContext differentiates from other interfaces. + IsLateralStatementContext() +} + +type LateralStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLateralStatementContext() *LateralStatementContext { + var p = new(LateralStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_lateralStatement + return p +} + +func InitEmptyLateralStatementContext(p *LateralStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_lateralStatement +} + +func (*LateralStatementContext) IsLateralStatementContext() {} + +func NewLateralStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LateralStatementContext { + var p = new(LateralStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_lateralStatement + + return p +} + +func (s *LateralStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *LateralStatementContext) LATERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserLATERAL, 0) +} + +func (s *LateralStatementContext) QuerySpecificationNointo() IQuerySpecificationNointoContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuerySpecificationNointoContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuerySpecificationNointoContext) +} + +func (s *LateralStatementContext) QueryExpressionNointo() IQueryExpressionNointoContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQueryExpressionNointoContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQueryExpressionNointoContext) +} + +func (s *LateralStatementContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *LateralStatementContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *LateralStatementContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *LateralStatementContext) AS() antlr.TerminalNode { + return s.GetToken(MySqlParserAS, 0) +} + +func (s *LateralStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LateralStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *LateralStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterLateralStatement(s) + } +} + +func (s *LateralStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitLateralStatement(s) + } +} + +func (p *MySqlParser) LateralStatement() (localctx ILateralStatementContext) { + localctx = NewLateralStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 260, MySqlParserRULE_lateralStatement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4003) + p.Match(MySqlParserLATERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4018) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 584, p.GetParserRuleContext()) { + case 1: + { + p.SetState(4004) + p.QuerySpecificationNointo() + } + + case 2: + { + p.SetState(4005) + p.QueryExpressionNointo() + } + + case 3: + { + p.SetState(4006) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4009) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserSELECT: + { + p.SetState(4007) + p.QuerySpecificationNointo() + } + + case MySqlParserLR_BRACKET: + { + p.SetState(4008) + p.QueryExpressionNointo() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(4011) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4016) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 583, p.GetParserRuleContext()) == 1 { + p.SetState(4013) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserAS { + { + p.SetState(4012) + p.Match(MySqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4015) + p.Uid() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJsonTableContext is an interface to support dynamic dispatch. +type IJsonTableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + JSON_TABLE() antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllSTRING_LITERAL() []antlr.TerminalNode + STRING_LITERAL(i int) antlr.TerminalNode + COMMA() antlr.TerminalNode + COLUMNS() antlr.TerminalNode + JsonColumnList() IJsonColumnListContext + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + Uid() IUidContext + AS() antlr.TerminalNode + + // IsJsonTableContext differentiates from other interfaces. + IsJsonTableContext() +} + +type JsonTableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJsonTableContext() *JsonTableContext { + var p = new(JsonTableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_jsonTable + return p +} + +func InitEmptyJsonTableContext(p *JsonTableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_jsonTable +} + +func (*JsonTableContext) IsJsonTableContext() {} + +func NewJsonTableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *JsonTableContext { + var p = new(JsonTableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_jsonTable + + return p +} + +func (s *JsonTableContext) GetParser() antlr.Parser { return s.parser } + +func (s *JsonTableContext) JSON_TABLE() antlr.TerminalNode { + return s.GetToken(MySqlParserJSON_TABLE, 0) +} + +func (s *JsonTableContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(MySqlParserLR_BRACKET) +} + +func (s *JsonTableContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, i) +} + +func (s *JsonTableContext) AllSTRING_LITERAL() []antlr.TerminalNode { + return s.GetTokens(MySqlParserSTRING_LITERAL) +} + +func (s *JsonTableContext) STRING_LITERAL(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, i) +} + +func (s *JsonTableContext) COMMA() antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, 0) +} + +func (s *JsonTableContext) COLUMNS() antlr.TerminalNode { + return s.GetToken(MySqlParserCOLUMNS, 0) +} + +func (s *JsonTableContext) JsonColumnList() IJsonColumnListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJsonColumnListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJsonColumnListContext) +} + +func (s *JsonTableContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(MySqlParserRR_BRACKET) +} + +func (s *JsonTableContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, i) +} + +func (s *JsonTableContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *JsonTableContext) AS() antlr.TerminalNode { + return s.GetToken(MySqlParserAS, 0) +} + +func (s *JsonTableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *JsonTableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *JsonTableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterJsonTable(s) + } +} + +func (s *JsonTableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitJsonTable(s) + } +} + +func (p *MySqlParser) JsonTable() (localctx IJsonTableContext) { + localctx = NewJsonTableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 262, MySqlParserRULE_jsonTable) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4020) + p.Match(MySqlParserJSON_TABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4021) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4022) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4023) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4024) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4025) + p.Match(MySqlParserCOLUMNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4026) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4027) + p.JsonColumnList() + } + { + p.SetState(4028) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4029) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4034) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 586, p.GetParserRuleContext()) == 1 { + p.SetState(4031) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserAS { + { + p.SetState(4030) + p.Match(MySqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4033) + p.Uid() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJsonColumnListContext is an interface to support dynamic dispatch. +type IJsonColumnListContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllJsonColumn() []IJsonColumnContext + JsonColumn(i int) IJsonColumnContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsJsonColumnListContext differentiates from other interfaces. + IsJsonColumnListContext() +} + +type JsonColumnListContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJsonColumnListContext() *JsonColumnListContext { + var p = new(JsonColumnListContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_jsonColumnList + return p +} + +func InitEmptyJsonColumnListContext(p *JsonColumnListContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_jsonColumnList +} + +func (*JsonColumnListContext) IsJsonColumnListContext() {} + +func NewJsonColumnListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *JsonColumnListContext { + var p = new(JsonColumnListContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_jsonColumnList + + return p +} + +func (s *JsonColumnListContext) GetParser() antlr.Parser { return s.parser } + +func (s *JsonColumnListContext) AllJsonColumn() []IJsonColumnContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IJsonColumnContext); ok { + len++ + } + } + + tst := make([]IJsonColumnContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IJsonColumnContext); ok { + tst[i] = t.(IJsonColumnContext) + i++ + } + } + + return tst +} + +func (s *JsonColumnListContext) JsonColumn(i int) IJsonColumnContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJsonColumnContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IJsonColumnContext) +} + +func (s *JsonColumnListContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *JsonColumnListContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *JsonColumnListContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *JsonColumnListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *JsonColumnListContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterJsonColumnList(s) + } +} + +func (s *JsonColumnListContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitJsonColumnList(s) + } +} + +func (p *MySqlParser) JsonColumnList() (localctx IJsonColumnListContext) { + localctx = NewJsonColumnListContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 264, MySqlParserRULE_jsonColumnList) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4036) + p.JsonColumn() + } + p.SetState(4041) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(4037) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4038) + p.JsonColumn() + } + + p.SetState(4043) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJsonColumnContext is an interface to support dynamic dispatch. +type IJsonColumnContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FullColumnName() IFullColumnNameContext + FOR() antlr.TerminalNode + ORDINALITY() antlr.TerminalNode + DataType() IDataTypeContext + PATH() antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + EXISTS() antlr.TerminalNode + JsonOnEmpty() IJsonOnEmptyContext + JsonOnError() IJsonOnErrorContext + NESTED() antlr.TerminalNode + COLUMNS() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + JsonColumnList() IJsonColumnListContext + RR_BRACKET() antlr.TerminalNode + + // IsJsonColumnContext differentiates from other interfaces. + IsJsonColumnContext() +} + +type JsonColumnContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJsonColumnContext() *JsonColumnContext { + var p = new(JsonColumnContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_jsonColumn + return p +} + +func InitEmptyJsonColumnContext(p *JsonColumnContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_jsonColumn +} + +func (*JsonColumnContext) IsJsonColumnContext() {} + +func NewJsonColumnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *JsonColumnContext { + var p = new(JsonColumnContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_jsonColumn + + return p +} + +func (s *JsonColumnContext) GetParser() antlr.Parser { return s.parser } + +func (s *JsonColumnContext) FullColumnName() IFullColumnNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFullColumnNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFullColumnNameContext) +} + +func (s *JsonColumnContext) FOR() antlr.TerminalNode { + return s.GetToken(MySqlParserFOR, 0) +} + +func (s *JsonColumnContext) ORDINALITY() antlr.TerminalNode { + return s.GetToken(MySqlParserORDINALITY, 0) +} + +func (s *JsonColumnContext) DataType() IDataTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDataTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDataTypeContext) +} + +func (s *JsonColumnContext) PATH() antlr.TerminalNode { + return s.GetToken(MySqlParserPATH, 0) +} + +func (s *JsonColumnContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *JsonColumnContext) EXISTS() antlr.TerminalNode { + return s.GetToken(MySqlParserEXISTS, 0) +} + +func (s *JsonColumnContext) JsonOnEmpty() IJsonOnEmptyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJsonOnEmptyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJsonOnEmptyContext) +} + +func (s *JsonColumnContext) JsonOnError() IJsonOnErrorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJsonOnErrorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJsonOnErrorContext) +} + +func (s *JsonColumnContext) NESTED() antlr.TerminalNode { + return s.GetToken(MySqlParserNESTED, 0) +} + +func (s *JsonColumnContext) COLUMNS() antlr.TerminalNode { + return s.GetToken(MySqlParserCOLUMNS, 0) +} + +func (s *JsonColumnContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *JsonColumnContext) JsonColumnList() IJsonColumnListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJsonColumnListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJsonColumnListContext) +} + +func (s *JsonColumnContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *JsonColumnContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *JsonColumnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *JsonColumnContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterJsonColumn(s) + } +} + +func (s *JsonColumnContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitJsonColumn(s) + } +} + +func (p *MySqlParser) JsonColumn() (localctx IJsonColumnContext) { + localctx = NewJsonColumnContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 266, MySqlParserRULE_jsonColumn) + var _la int + + p.SetState(4073) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 593, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4044) + p.FullColumnName() + } + p.SetState(4061) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserFOR: + { + p.SetState(4045) + p.Match(MySqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4046) + p.Match(MySqlParserORDINALITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserCHARACTER, MySqlParserSET, MySqlParserTINYINT, MySqlParserSMALLINT, MySqlParserMEDIUMINT, MySqlParserMIDDLEINT, MySqlParserINT, MySqlParserINT1, MySqlParserINT2, MySqlParserINT3, MySqlParserINT4, MySqlParserINT8, MySqlParserINTEGER, MySqlParserBIGINT, MySqlParserREAL, MySqlParserDOUBLE, MySqlParserFLOAT, MySqlParserFLOAT4, MySqlParserFLOAT8, MySqlParserDECIMAL, MySqlParserDEC, MySqlParserNUMERIC, MySqlParserDATE, MySqlParserTIME, MySqlParserTIMESTAMP, MySqlParserDATETIME, MySqlParserYEAR, MySqlParserCHAR, MySqlParserVARCHAR, MySqlParserNVARCHAR, MySqlParserNATIONAL, MySqlParserBINARY, MySqlParserVARBINARY, MySqlParserTINYBLOB, MySqlParserBLOB, MySqlParserMEDIUMBLOB, MySqlParserLONG, MySqlParserLONGBLOB, MySqlParserTINYTEXT, MySqlParserTEXT, MySqlParserMEDIUMTEXT, MySqlParserLONGTEXT, MySqlParserENUM, MySqlParserSERIAL, MySqlParserVECTOR, MySqlParserBIT, MySqlParserBOOL, MySqlParserBOOLEAN, MySqlParserFIXED, MySqlParserJSON, MySqlParserNCHAR, MySqlParserGEOMETRYCOLLECTION, MySqlParserGEOMCOLLECTION, MySqlParserGEOMETRY, MySqlParserLINESTRING, MySqlParserMULTILINESTRING, MySqlParserMULTIPOINT, MySqlParserMULTIPOLYGON, MySqlParserPOINT, MySqlParserPOLYGON: + { + p.SetState(4047) + p.DataType() + } + p.SetState(4059) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserPATH: + { + p.SetState(4048) + p.Match(MySqlParserPATH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4049) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4051) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 588, p.GetParserRuleContext()) == 1 { + { + p.SetState(4050) + p.JsonOnEmpty() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4054) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserDEFAULT || _la == MySqlParserNULL_LITERAL || _la == MySqlParserERROR { + { + p.SetState(4053) + p.JsonOnError() + } + + } + + case MySqlParserEXISTS: + { + p.SetState(4056) + p.Match(MySqlParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4057) + p.Match(MySqlParserPATH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4058) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4063) + p.Match(MySqlParserNESTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4065) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserPATH { + { + p.SetState(4064) + p.Match(MySqlParserPATH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4067) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4068) + p.Match(MySqlParserCOLUMNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4069) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4070) + p.JsonColumnList() + } + { + p.SetState(4071) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJsonOnEmptyContext is an interface to support dynamic dispatch. +type IJsonOnEmptyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ON() antlr.TerminalNode + EMPTY() antlr.TerminalNode + NULL_LITERAL() antlr.TerminalNode + ERROR() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + DefaultValue() IDefaultValueContext + + // IsJsonOnEmptyContext differentiates from other interfaces. + IsJsonOnEmptyContext() +} + +type JsonOnEmptyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJsonOnEmptyContext() *JsonOnEmptyContext { + var p = new(JsonOnEmptyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_jsonOnEmpty + return p +} + +func InitEmptyJsonOnEmptyContext(p *JsonOnEmptyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_jsonOnEmpty +} + +func (*JsonOnEmptyContext) IsJsonOnEmptyContext() {} + +func NewJsonOnEmptyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *JsonOnEmptyContext { + var p = new(JsonOnEmptyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_jsonOnEmpty + + return p +} + +func (s *JsonOnEmptyContext) GetParser() antlr.Parser { return s.parser } + +func (s *JsonOnEmptyContext) ON() antlr.TerminalNode { + return s.GetToken(MySqlParserON, 0) +} + +func (s *JsonOnEmptyContext) EMPTY() antlr.TerminalNode { + return s.GetToken(MySqlParserEMPTY, 0) +} + +func (s *JsonOnEmptyContext) NULL_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserNULL_LITERAL, 0) +} + +func (s *JsonOnEmptyContext) ERROR() antlr.TerminalNode { + return s.GetToken(MySqlParserERROR, 0) +} + +func (s *JsonOnEmptyContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(MySqlParserDEFAULT, 0) +} + +func (s *JsonOnEmptyContext) DefaultValue() IDefaultValueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefaultValueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefaultValueContext) +} + +func (s *JsonOnEmptyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *JsonOnEmptyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *JsonOnEmptyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterJsonOnEmpty(s) + } +} + +func (s *JsonOnEmptyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitJsonOnEmpty(s) + } +} + +func (p *MySqlParser) JsonOnEmpty() (localctx IJsonOnEmptyContext) { + localctx = NewJsonOnEmptyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 268, MySqlParserRULE_jsonOnEmpty) + p.EnterOuterAlt(localctx, 1) + p.SetState(4079) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserNULL_LITERAL: + { + p.SetState(4075) + p.Match(MySqlParserNULL_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserERROR: + { + p.SetState(4076) + p.Match(MySqlParserERROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserDEFAULT: + { + p.SetState(4077) + p.Match(MySqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4078) + p.DefaultValue() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(4081) + p.Match(MySqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4082) + p.Match(MySqlParserEMPTY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJsonOnErrorContext is an interface to support dynamic dispatch. +type IJsonOnErrorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ON() antlr.TerminalNode + AllERROR() []antlr.TerminalNode + ERROR(i int) antlr.TerminalNode + NULL_LITERAL() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + DefaultValue() IDefaultValueContext + + // IsJsonOnErrorContext differentiates from other interfaces. + IsJsonOnErrorContext() +} + +type JsonOnErrorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJsonOnErrorContext() *JsonOnErrorContext { + var p = new(JsonOnErrorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_jsonOnError + return p +} + +func InitEmptyJsonOnErrorContext(p *JsonOnErrorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_jsonOnError +} + +func (*JsonOnErrorContext) IsJsonOnErrorContext() {} + +func NewJsonOnErrorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *JsonOnErrorContext { + var p = new(JsonOnErrorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_jsonOnError + + return p +} + +func (s *JsonOnErrorContext) GetParser() antlr.Parser { return s.parser } + +func (s *JsonOnErrorContext) ON() antlr.TerminalNode { + return s.GetToken(MySqlParserON, 0) +} + +func (s *JsonOnErrorContext) AllERROR() []antlr.TerminalNode { + return s.GetTokens(MySqlParserERROR) +} + +func (s *JsonOnErrorContext) ERROR(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserERROR, i) +} + +func (s *JsonOnErrorContext) NULL_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserNULL_LITERAL, 0) +} + +func (s *JsonOnErrorContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(MySqlParserDEFAULT, 0) +} + +func (s *JsonOnErrorContext) DefaultValue() IDefaultValueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefaultValueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefaultValueContext) +} + +func (s *JsonOnErrorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *JsonOnErrorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *JsonOnErrorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterJsonOnError(s) + } +} + +func (s *JsonOnErrorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitJsonOnError(s) + } +} + +func (p *MySqlParser) JsonOnError() (localctx IJsonOnErrorContext) { + localctx = NewJsonOnErrorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 270, MySqlParserRULE_jsonOnError) + p.EnterOuterAlt(localctx, 1) + p.SetState(4088) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserNULL_LITERAL: + { + p.SetState(4084) + p.Match(MySqlParserNULL_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserERROR: + { + p.SetState(4085) + p.Match(MySqlParserERROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserDEFAULT: + { + p.SetState(4086) + p.Match(MySqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4087) + p.DefaultValue() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(4090) + p.Match(MySqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4091) + p.Match(MySqlParserERROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISelectSpecContext is an interface to support dynamic dispatch. +type ISelectSpecContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALL() antlr.TerminalNode + DISTINCT() antlr.TerminalNode + DISTINCTROW() antlr.TerminalNode + HIGH_PRIORITY() antlr.TerminalNode + STRAIGHT_JOIN() antlr.TerminalNode + SQL_SMALL_RESULT() antlr.TerminalNode + SQL_BIG_RESULT() antlr.TerminalNode + SQL_BUFFER_RESULT() antlr.TerminalNode + SQL_CACHE() antlr.TerminalNode + SQL_NO_CACHE() antlr.TerminalNode + SQL_CALC_FOUND_ROWS() antlr.TerminalNode + + // IsSelectSpecContext differentiates from other interfaces. + IsSelectSpecContext() +} + +type SelectSpecContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelectSpecContext() *SelectSpecContext { + var p = new(SelectSpecContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_selectSpec + return p +} + +func InitEmptySelectSpecContext(p *SelectSpecContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_selectSpec +} + +func (*SelectSpecContext) IsSelectSpecContext() {} + +func NewSelectSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SelectSpecContext { + var p = new(SelectSpecContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_selectSpec + + return p +} + +func (s *SelectSpecContext) GetParser() antlr.Parser { return s.parser } + +func (s *SelectSpecContext) ALL() antlr.TerminalNode { + return s.GetToken(MySqlParserALL, 0) +} + +func (s *SelectSpecContext) DISTINCT() antlr.TerminalNode { + return s.GetToken(MySqlParserDISTINCT, 0) +} + +func (s *SelectSpecContext) DISTINCTROW() antlr.TerminalNode { + return s.GetToken(MySqlParserDISTINCTROW, 0) +} + +func (s *SelectSpecContext) HIGH_PRIORITY() antlr.TerminalNode { + return s.GetToken(MySqlParserHIGH_PRIORITY, 0) +} + +func (s *SelectSpecContext) STRAIGHT_JOIN() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRAIGHT_JOIN, 0) +} + +func (s *SelectSpecContext) SQL_SMALL_RESULT() antlr.TerminalNode { + return s.GetToken(MySqlParserSQL_SMALL_RESULT, 0) +} + +func (s *SelectSpecContext) SQL_BIG_RESULT() antlr.TerminalNode { + return s.GetToken(MySqlParserSQL_BIG_RESULT, 0) +} + +func (s *SelectSpecContext) SQL_BUFFER_RESULT() antlr.TerminalNode { + return s.GetToken(MySqlParserSQL_BUFFER_RESULT, 0) +} + +func (s *SelectSpecContext) SQL_CACHE() antlr.TerminalNode { + return s.GetToken(MySqlParserSQL_CACHE, 0) +} + +func (s *SelectSpecContext) SQL_NO_CACHE() antlr.TerminalNode { + return s.GetToken(MySqlParserSQL_NO_CACHE, 0) +} + +func (s *SelectSpecContext) SQL_CALC_FOUND_ROWS() antlr.TerminalNode { + return s.GetToken(MySqlParserSQL_CALC_FOUND_ROWS, 0) +} + +func (s *SelectSpecContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SelectSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SelectSpecContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSelectSpec(s) + } +} + +func (s *SelectSpecContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSelectSpec(s) + } +} + +func (p *MySqlParser) SelectSpec() (localctx ISelectSpecContext) { + localctx = NewSelectSpecContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 272, MySqlParserRULE_selectSpec) + var _la int + + p.SetState(4101) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserALL, MySqlParserDISTINCT, MySqlParserDISTINCTROW: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4093) + _la = p.GetTokenStream().LA(1) + + if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&1688849860264000) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case MySqlParserHIGH_PRIORITY: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4094) + p.Match(MySqlParserHIGH_PRIORITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserSTRAIGHT_JOIN: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4095) + p.Match(MySqlParserSTRAIGHT_JOIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserSQL_SMALL_RESULT: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4096) + p.Match(MySqlParserSQL_SMALL_RESULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserSQL_BIG_RESULT: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(4097) + p.Match(MySqlParserSQL_BIG_RESULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserSQL_BUFFER_RESULT: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(4098) + p.Match(MySqlParserSQL_BUFFER_RESULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserSQL_CACHE, MySqlParserSQL_NO_CACHE: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(4099) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserSQL_CACHE || _la == MySqlParserSQL_NO_CACHE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case MySqlParserSQL_CALC_FOUND_ROWS: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(4100) + p.Match(MySqlParserSQL_CALC_FOUND_ROWS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISelectElementsContext is an interface to support dynamic dispatch. +type ISelectElementsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetStar returns the star token. + GetStar() antlr.Token + + // SetStar sets the star token. + SetStar(antlr.Token) + + // Getter signatures + AllSelectElement() []ISelectElementContext + SelectElement(i int) ISelectElementContext + STAR() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsSelectElementsContext differentiates from other interfaces. + IsSelectElementsContext() +} + +type SelectElementsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + star antlr.Token +} + +func NewEmptySelectElementsContext() *SelectElementsContext { + var p = new(SelectElementsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_selectElements + return p +} + +func InitEmptySelectElementsContext(p *SelectElementsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_selectElements +} + +func (*SelectElementsContext) IsSelectElementsContext() {} + +func NewSelectElementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SelectElementsContext { + var p = new(SelectElementsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_selectElements + + return p +} + +func (s *SelectElementsContext) GetParser() antlr.Parser { return s.parser } + +func (s *SelectElementsContext) GetStar() antlr.Token { return s.star } + +func (s *SelectElementsContext) SetStar(v antlr.Token) { s.star = v } + +func (s *SelectElementsContext) AllSelectElement() []ISelectElementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISelectElementContext); ok { + len++ + } + } + + tst := make([]ISelectElementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISelectElementContext); ok { + tst[i] = t.(ISelectElementContext) + i++ + } + } + + return tst +} + +func (s *SelectElementsContext) SelectElement(i int) ISelectElementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelectElementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISelectElementContext) +} + +func (s *SelectElementsContext) STAR() antlr.TerminalNode { + return s.GetToken(MySqlParserSTAR, 0) +} + +func (s *SelectElementsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *SelectElementsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *SelectElementsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SelectElementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SelectElementsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSelectElements(s) + } +} + +func (s *SelectElementsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSelectElements(s) + } +} + +func (p *MySqlParser) SelectElements() (localctx ISelectElementsContext) { + localctx = NewSelectElementsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 274, MySqlParserRULE_selectElements) + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(4105) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 597, p.GetParserRuleContext()) { + case 1: + { + p.SetState(4103) + + var _m = p.Match(MySqlParserSTAR) + + localctx.(*SelectElementsContext).star = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(4104) + p.SelectElement() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(4111) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 598, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(4107) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4108) + p.SelectElement() + } + + } + p.SetState(4113) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 598, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISelectElementContext is an interface to support dynamic dispatch. +type ISelectElementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsSelectElementContext differentiates from other interfaces. + IsSelectElementContext() +} + +type SelectElementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelectElementContext() *SelectElementContext { + var p = new(SelectElementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_selectElement + return p +} + +func InitEmptySelectElementContext(p *SelectElementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_selectElement +} + +func (*SelectElementContext) IsSelectElementContext() {} + +func NewSelectElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SelectElementContext { + var p = new(SelectElementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_selectElement + + return p +} + +func (s *SelectElementContext) GetParser() antlr.Parser { return s.parser } + +func (s *SelectElementContext) CopyAll(ctx *SelectElementContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *SelectElementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SelectElementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type SelectExpressionElementContext struct { + SelectElementContext +} + +func NewSelectExpressionElementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SelectExpressionElementContext { + var p = new(SelectExpressionElementContext) + + InitEmptySelectElementContext(&p.SelectElementContext) + p.parser = parser + p.CopyAll(ctx.(*SelectElementContext)) + + return p +} + +func (s *SelectExpressionElementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SelectExpressionElementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *SelectExpressionElementContext) LOCAL_ID() antlr.TerminalNode { + return s.GetToken(MySqlParserLOCAL_ID, 0) +} + +func (s *SelectExpressionElementContext) VAR_ASSIGN() antlr.TerminalNode { + return s.GetToken(MySqlParserVAR_ASSIGN, 0) +} + +func (s *SelectExpressionElementContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *SelectExpressionElementContext) AS() antlr.TerminalNode { + return s.GetToken(MySqlParserAS, 0) +} + +func (s *SelectExpressionElementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSelectExpressionElement(s) + } +} + +func (s *SelectExpressionElementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSelectExpressionElement(s) + } +} + +type SelectFunctionElementContext struct { + SelectElementContext +} + +func NewSelectFunctionElementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SelectFunctionElementContext { + var p = new(SelectFunctionElementContext) + + InitEmptySelectElementContext(&p.SelectElementContext) + p.parser = parser + p.CopyAll(ctx.(*SelectElementContext)) + + return p +} + +func (s *SelectFunctionElementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SelectFunctionElementContext) FunctionCall() IFunctionCallContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionCallContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunctionCallContext) +} + +func (s *SelectFunctionElementContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *SelectFunctionElementContext) AS() antlr.TerminalNode { + return s.GetToken(MySqlParserAS, 0) +} + +func (s *SelectFunctionElementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSelectFunctionElement(s) + } +} + +func (s *SelectFunctionElementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSelectFunctionElement(s) + } +} + +type SelectStarElementContext struct { + SelectElementContext +} + +func NewSelectStarElementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SelectStarElementContext { + var p = new(SelectStarElementContext) + + InitEmptySelectElementContext(&p.SelectElementContext) + p.parser = parser + p.CopyAll(ctx.(*SelectElementContext)) + + return p +} + +func (s *SelectStarElementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SelectStarElementContext) FullId() IFullIdContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFullIdContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFullIdContext) +} + +func (s *SelectStarElementContext) DOT() antlr.TerminalNode { + return s.GetToken(MySqlParserDOT, 0) +} + +func (s *SelectStarElementContext) STAR() antlr.TerminalNode { + return s.GetToken(MySqlParserSTAR, 0) +} + +func (s *SelectStarElementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSelectStarElement(s) + } +} + +func (s *SelectStarElementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSelectStarElement(s) + } +} + +type SelectColumnElementContext struct { + SelectElementContext +} + +func NewSelectColumnElementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SelectColumnElementContext { + var p = new(SelectColumnElementContext) + + InitEmptySelectElementContext(&p.SelectElementContext) + p.parser = parser + p.CopyAll(ctx.(*SelectElementContext)) + + return p +} + +func (s *SelectColumnElementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SelectColumnElementContext) FullColumnName() IFullColumnNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFullColumnNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFullColumnNameContext) +} + +func (s *SelectColumnElementContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *SelectColumnElementContext) AS() antlr.TerminalNode { + return s.GetToken(MySqlParserAS, 0) +} + +func (s *SelectColumnElementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSelectColumnElement(s) + } +} + +func (s *SelectColumnElementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSelectColumnElement(s) + } +} + +func (p *MySqlParser) SelectElement() (localctx ISelectElementContext) { + localctx = NewSelectElementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 276, MySqlParserRULE_selectElement) + var _la int + + p.SetState(4143) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 606, p.GetParserRuleContext()) { + case 1: + localctx = NewSelectStarElementContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4114) + p.FullId() + } + { + p.SetState(4115) + p.Match(MySqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4116) + p.Match(MySqlParserSTAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + localctx = NewSelectColumnElementContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4118) + p.FullColumnName() + } + p.SetState(4123) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 600, p.GetParserRuleContext()) == 1 { + p.SetState(4120) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserAS { + { + p.SetState(4119) + p.Match(MySqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4122) + p.Uid() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 3: + localctx = NewSelectFunctionElementContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4125) + p.FunctionCall() + } + p.SetState(4130) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 602, p.GetParserRuleContext()) == 1 { + p.SetState(4127) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserAS { + { + p.SetState(4126) + p.Match(MySqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4129) + p.Uid() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 4: + localctx = NewSelectExpressionElementContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + p.SetState(4134) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 603, p.GetParserRuleContext()) == 1 { + { + p.SetState(4132) + p.Match(MySqlParserLOCAL_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4133) + p.Match(MySqlParserVAR_ASSIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4136) + p.expression(0) + } + p.SetState(4141) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 605, p.GetParserRuleContext()) == 1 { + p.SetState(4138) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserAS { + { + p.SetState(4137) + p.Match(MySqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4140) + p.Uid() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISelectIntoExpressionContext is an interface to support dynamic dispatch. +type ISelectIntoExpressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsSelectIntoExpressionContext differentiates from other interfaces. + IsSelectIntoExpressionContext() +} + +type SelectIntoExpressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelectIntoExpressionContext() *SelectIntoExpressionContext { + var p = new(SelectIntoExpressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_selectIntoExpression + return p +} + +func InitEmptySelectIntoExpressionContext(p *SelectIntoExpressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_selectIntoExpression +} + +func (*SelectIntoExpressionContext) IsSelectIntoExpressionContext() {} + +func NewSelectIntoExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SelectIntoExpressionContext { + var p = new(SelectIntoExpressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_selectIntoExpression + + return p +} + +func (s *SelectIntoExpressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *SelectIntoExpressionContext) CopyAll(ctx *SelectIntoExpressionContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *SelectIntoExpressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SelectIntoExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type SelectIntoVariablesContext struct { + SelectIntoExpressionContext +} + +func NewSelectIntoVariablesContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SelectIntoVariablesContext { + var p = new(SelectIntoVariablesContext) + + InitEmptySelectIntoExpressionContext(&p.SelectIntoExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*SelectIntoExpressionContext)) + + return p +} + +func (s *SelectIntoVariablesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SelectIntoVariablesContext) INTO() antlr.TerminalNode { + return s.GetToken(MySqlParserINTO, 0) +} + +func (s *SelectIntoVariablesContext) AllAssignmentField() []IAssignmentFieldContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAssignmentFieldContext); ok { + len++ + } + } + + tst := make([]IAssignmentFieldContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAssignmentFieldContext); ok { + tst[i] = t.(IAssignmentFieldContext) + i++ + } + } + + return tst +} + +func (s *SelectIntoVariablesContext) AssignmentField(i int) IAssignmentFieldContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAssignmentFieldContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAssignmentFieldContext) +} + +func (s *SelectIntoVariablesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *SelectIntoVariablesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *SelectIntoVariablesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSelectIntoVariables(s) + } +} + +func (s *SelectIntoVariablesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSelectIntoVariables(s) + } +} + +type SelectIntoTextFileContext struct { + SelectIntoExpressionContext + filename antlr.Token + charset ICharsetNameContext + fieldsFormat antlr.Token +} + +func NewSelectIntoTextFileContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SelectIntoTextFileContext { + var p = new(SelectIntoTextFileContext) + + InitEmptySelectIntoExpressionContext(&p.SelectIntoExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*SelectIntoExpressionContext)) + + return p +} + +func (s *SelectIntoTextFileContext) GetFilename() antlr.Token { return s.filename } + +func (s *SelectIntoTextFileContext) GetFieldsFormat() antlr.Token { return s.fieldsFormat } + +func (s *SelectIntoTextFileContext) SetFilename(v antlr.Token) { s.filename = v } + +func (s *SelectIntoTextFileContext) SetFieldsFormat(v antlr.Token) { s.fieldsFormat = v } + +func (s *SelectIntoTextFileContext) GetCharset() ICharsetNameContext { return s.charset } + +func (s *SelectIntoTextFileContext) SetCharset(v ICharsetNameContext) { s.charset = v } + +func (s *SelectIntoTextFileContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SelectIntoTextFileContext) INTO() antlr.TerminalNode { + return s.GetToken(MySqlParserINTO, 0) +} + +func (s *SelectIntoTextFileContext) OUTFILE() antlr.TerminalNode { + return s.GetToken(MySqlParserOUTFILE, 0) +} + +func (s *SelectIntoTextFileContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *SelectIntoTextFileContext) CHARACTER() antlr.TerminalNode { + return s.GetToken(MySqlParserCHARACTER, 0) +} + +func (s *SelectIntoTextFileContext) SET() antlr.TerminalNode { + return s.GetToken(MySqlParserSET, 0) +} + +func (s *SelectIntoTextFileContext) LINES() antlr.TerminalNode { + return s.GetToken(MySqlParserLINES, 0) +} + +func (s *SelectIntoTextFileContext) CharsetName() ICharsetNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICharsetNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICharsetNameContext) +} + +func (s *SelectIntoTextFileContext) FIELDS() antlr.TerminalNode { + return s.GetToken(MySqlParserFIELDS, 0) +} + +func (s *SelectIntoTextFileContext) COLUMNS() antlr.TerminalNode { + return s.GetToken(MySqlParserCOLUMNS, 0) +} + +func (s *SelectIntoTextFileContext) AllSelectFieldsInto() []ISelectFieldsIntoContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISelectFieldsIntoContext); ok { + len++ + } + } + + tst := make([]ISelectFieldsIntoContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISelectFieldsIntoContext); ok { + tst[i] = t.(ISelectFieldsIntoContext) + i++ + } + } + + return tst +} + +func (s *SelectIntoTextFileContext) SelectFieldsInto(i int) ISelectFieldsIntoContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelectFieldsIntoContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISelectFieldsIntoContext) +} + +func (s *SelectIntoTextFileContext) AllSelectLinesInto() []ISelectLinesIntoContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISelectLinesIntoContext); ok { + len++ + } + } + + tst := make([]ISelectLinesIntoContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISelectLinesIntoContext); ok { + tst[i] = t.(ISelectLinesIntoContext) + i++ + } + } + + return tst +} + +func (s *SelectIntoTextFileContext) SelectLinesInto(i int) ISelectLinesIntoContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelectLinesIntoContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISelectLinesIntoContext) +} + +func (s *SelectIntoTextFileContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSelectIntoTextFile(s) + } +} + +func (s *SelectIntoTextFileContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSelectIntoTextFile(s) + } +} + +type SelectIntoDumpFileContext struct { + SelectIntoExpressionContext +} + +func NewSelectIntoDumpFileContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SelectIntoDumpFileContext { + var p = new(SelectIntoDumpFileContext) + + InitEmptySelectIntoExpressionContext(&p.SelectIntoExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*SelectIntoExpressionContext)) + + return p +} + +func (s *SelectIntoDumpFileContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SelectIntoDumpFileContext) INTO() antlr.TerminalNode { + return s.GetToken(MySqlParserINTO, 0) +} + +func (s *SelectIntoDumpFileContext) DUMPFILE() antlr.TerminalNode { + return s.GetToken(MySqlParserDUMPFILE, 0) +} + +func (s *SelectIntoDumpFileContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *SelectIntoDumpFileContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSelectIntoDumpFile(s) + } +} + +func (s *SelectIntoDumpFileContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSelectIntoDumpFile(s) + } +} + +func (p *MySqlParser) SelectIntoExpression() (localctx ISelectIntoExpressionContext) { + localctx = NewSelectIntoExpressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 278, MySqlParserRULE_selectIntoExpression) + var _la int + + p.SetState(4181) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 613, p.GetParserRuleContext()) { + case 1: + localctx = NewSelectIntoVariablesContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4145) + p.Match(MySqlParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4146) + p.AssignmentField() + } + p.SetState(4151) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(4147) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4148) + p.AssignmentField() + } + + p.SetState(4153) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 2: + localctx = NewSelectIntoDumpFileContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4154) + p.Match(MySqlParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4155) + p.Match(MySqlParserDUMPFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4156) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + localctx = NewSelectIntoTextFileContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4157) + p.Match(MySqlParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4158) + p.Match(MySqlParserOUTFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4159) + + var _m = p.Match(MySqlParserSTRING_LITERAL) + + localctx.(*SelectIntoTextFileContext).filename = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4163) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserCHARACTER { + { + p.SetState(4160) + p.Match(MySqlParserCHARACTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4161) + p.Match(MySqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4162) + + var _x = p.CharsetName() + + localctx.(*SelectIntoTextFileContext).charset = _x + } + + } + p.SetState(4171) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 610, p.GetParserRuleContext()) == 1 { + { + p.SetState(4165) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*SelectIntoTextFileContext).fieldsFormat = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserCOLUMNS || _la == MySqlParserFIELDS) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*SelectIntoTextFileContext).fieldsFormat = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(4167) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == MySqlParserENCLOSED || _la == MySqlParserESCAPED || _la == MySqlParserOPTIONALLY || _la == MySqlParserTERMINATED { + { + p.SetState(4166) + p.SelectFieldsInto() + } + + p.SetState(4169) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4179) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserLINES { + { + p.SetState(4173) + p.Match(MySqlParserLINES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4175) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == MySqlParserSTARTING || _la == MySqlParserTERMINATED { + { + p.SetState(4174) + p.SelectLinesInto() + } + + p.SetState(4177) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISelectFieldsIntoContext is an interface to support dynamic dispatch. +type ISelectFieldsIntoContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetTerminationField returns the terminationField token. + GetTerminationField() antlr.Token + + // GetEnclosion returns the enclosion token. + GetEnclosion() antlr.Token + + // GetEscaping returns the escaping token. + GetEscaping() antlr.Token + + // SetTerminationField sets the terminationField token. + SetTerminationField(antlr.Token) + + // SetEnclosion sets the enclosion token. + SetEnclosion(antlr.Token) + + // SetEscaping sets the escaping token. + SetEscaping(antlr.Token) + + // Getter signatures + TERMINATED() antlr.TerminalNode + BY() antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + ENCLOSED() antlr.TerminalNode + OPTIONALLY() antlr.TerminalNode + ESCAPED() antlr.TerminalNode + + // IsSelectFieldsIntoContext differentiates from other interfaces. + IsSelectFieldsIntoContext() +} + +type SelectFieldsIntoContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + terminationField antlr.Token + enclosion antlr.Token + escaping antlr.Token +} + +func NewEmptySelectFieldsIntoContext() *SelectFieldsIntoContext { + var p = new(SelectFieldsIntoContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_selectFieldsInto + return p +} + +func InitEmptySelectFieldsIntoContext(p *SelectFieldsIntoContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_selectFieldsInto +} + +func (*SelectFieldsIntoContext) IsSelectFieldsIntoContext() {} + +func NewSelectFieldsIntoContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SelectFieldsIntoContext { + var p = new(SelectFieldsIntoContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_selectFieldsInto + + return p +} + +func (s *SelectFieldsIntoContext) GetParser() antlr.Parser { return s.parser } + +func (s *SelectFieldsIntoContext) GetTerminationField() antlr.Token { return s.terminationField } + +func (s *SelectFieldsIntoContext) GetEnclosion() antlr.Token { return s.enclosion } + +func (s *SelectFieldsIntoContext) GetEscaping() antlr.Token { return s.escaping } + +func (s *SelectFieldsIntoContext) SetTerminationField(v antlr.Token) { s.terminationField = v } + +func (s *SelectFieldsIntoContext) SetEnclosion(v antlr.Token) { s.enclosion = v } + +func (s *SelectFieldsIntoContext) SetEscaping(v antlr.Token) { s.escaping = v } + +func (s *SelectFieldsIntoContext) TERMINATED() antlr.TerminalNode { + return s.GetToken(MySqlParserTERMINATED, 0) +} + +func (s *SelectFieldsIntoContext) BY() antlr.TerminalNode { + return s.GetToken(MySqlParserBY, 0) +} + +func (s *SelectFieldsIntoContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *SelectFieldsIntoContext) ENCLOSED() antlr.TerminalNode { + return s.GetToken(MySqlParserENCLOSED, 0) +} + +func (s *SelectFieldsIntoContext) OPTIONALLY() antlr.TerminalNode { + return s.GetToken(MySqlParserOPTIONALLY, 0) +} + +func (s *SelectFieldsIntoContext) ESCAPED() antlr.TerminalNode { + return s.GetToken(MySqlParserESCAPED, 0) +} + +func (s *SelectFieldsIntoContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SelectFieldsIntoContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SelectFieldsIntoContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSelectFieldsInto(s) + } +} + +func (s *SelectFieldsIntoContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSelectFieldsInto(s) + } +} + +func (p *MySqlParser) SelectFieldsInto() (localctx ISelectFieldsIntoContext) { + localctx = NewSelectFieldsIntoContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 280, MySqlParserRULE_selectFieldsInto) + var _la int + + p.SetState(4195) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserTERMINATED: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4183) + p.Match(MySqlParserTERMINATED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4184) + p.Match(MySqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4185) + + var _m = p.Match(MySqlParserSTRING_LITERAL) + + localctx.(*SelectFieldsIntoContext).terminationField = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserENCLOSED, MySqlParserOPTIONALLY: + p.EnterOuterAlt(localctx, 2) + p.SetState(4187) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserOPTIONALLY { + { + p.SetState(4186) + p.Match(MySqlParserOPTIONALLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4189) + p.Match(MySqlParserENCLOSED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4190) + p.Match(MySqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4191) + + var _m = p.Match(MySqlParserSTRING_LITERAL) + + localctx.(*SelectFieldsIntoContext).enclosion = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserESCAPED: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4192) + p.Match(MySqlParserESCAPED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4193) + p.Match(MySqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4194) + + var _m = p.Match(MySqlParserSTRING_LITERAL) + + localctx.(*SelectFieldsIntoContext).escaping = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISelectLinesIntoContext is an interface to support dynamic dispatch. +type ISelectLinesIntoContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetStarting returns the starting token. + GetStarting() antlr.Token + + // GetTerminationLine returns the terminationLine token. + GetTerminationLine() antlr.Token + + // SetStarting sets the starting token. + SetStarting(antlr.Token) + + // SetTerminationLine sets the terminationLine token. + SetTerminationLine(antlr.Token) + + // Getter signatures + STARTING() antlr.TerminalNode + BY() antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + TERMINATED() antlr.TerminalNode + + // IsSelectLinesIntoContext differentiates from other interfaces. + IsSelectLinesIntoContext() +} + +type SelectLinesIntoContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + starting antlr.Token + terminationLine antlr.Token +} + +func NewEmptySelectLinesIntoContext() *SelectLinesIntoContext { + var p = new(SelectLinesIntoContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_selectLinesInto + return p +} + +func InitEmptySelectLinesIntoContext(p *SelectLinesIntoContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_selectLinesInto +} + +func (*SelectLinesIntoContext) IsSelectLinesIntoContext() {} + +func NewSelectLinesIntoContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SelectLinesIntoContext { + var p = new(SelectLinesIntoContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_selectLinesInto + + return p +} + +func (s *SelectLinesIntoContext) GetParser() antlr.Parser { return s.parser } + +func (s *SelectLinesIntoContext) GetStarting() antlr.Token { return s.starting } + +func (s *SelectLinesIntoContext) GetTerminationLine() antlr.Token { return s.terminationLine } + +func (s *SelectLinesIntoContext) SetStarting(v antlr.Token) { s.starting = v } + +func (s *SelectLinesIntoContext) SetTerminationLine(v antlr.Token) { s.terminationLine = v } + +func (s *SelectLinesIntoContext) STARTING() antlr.TerminalNode { + return s.GetToken(MySqlParserSTARTING, 0) +} + +func (s *SelectLinesIntoContext) BY() antlr.TerminalNode { + return s.GetToken(MySqlParserBY, 0) +} + +func (s *SelectLinesIntoContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *SelectLinesIntoContext) TERMINATED() antlr.TerminalNode { + return s.GetToken(MySqlParserTERMINATED, 0) +} + +func (s *SelectLinesIntoContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SelectLinesIntoContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SelectLinesIntoContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSelectLinesInto(s) + } +} + +func (s *SelectLinesIntoContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSelectLinesInto(s) + } +} + +func (p *MySqlParser) SelectLinesInto() (localctx ISelectLinesIntoContext) { + localctx = NewSelectLinesIntoContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 282, MySqlParserRULE_selectLinesInto) + p.SetState(4203) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserSTARTING: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4197) + p.Match(MySqlParserSTARTING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4198) + p.Match(MySqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4199) + + var _m = p.Match(MySqlParserSTRING_LITERAL) + + localctx.(*SelectLinesIntoContext).starting = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserTERMINATED: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4200) + p.Match(MySqlParserTERMINATED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4201) + p.Match(MySqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4202) + + var _m = p.Match(MySqlParserSTRING_LITERAL) + + localctx.(*SelectLinesIntoContext).terminationLine = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFromClauseContext is an interface to support dynamic dispatch. +type IFromClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetWhereExpr returns the whereExpr rule contexts. + GetWhereExpr() IExpressionContext + + // SetWhereExpr sets the whereExpr rule contexts. + SetWhereExpr(IExpressionContext) + + // Getter signatures + FROM() antlr.TerminalNode + TableSources() ITableSourcesContext + WHERE() antlr.TerminalNode + Expression() IExpressionContext + + // IsFromClauseContext differentiates from other interfaces. + IsFromClauseContext() +} + +type FromClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + whereExpr IExpressionContext +} + +func NewEmptyFromClauseContext() *FromClauseContext { + var p = new(FromClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_fromClause + return p +} + +func InitEmptyFromClauseContext(p *FromClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_fromClause +} + +func (*FromClauseContext) IsFromClauseContext() {} + +func NewFromClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FromClauseContext { + var p = new(FromClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_fromClause + + return p +} + +func (s *FromClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *FromClauseContext) GetWhereExpr() IExpressionContext { return s.whereExpr } + +func (s *FromClauseContext) SetWhereExpr(v IExpressionContext) { s.whereExpr = v } + +func (s *FromClauseContext) FROM() antlr.TerminalNode { + return s.GetToken(MySqlParserFROM, 0) +} + +func (s *FromClauseContext) TableSources() ITableSourcesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableSourcesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableSourcesContext) +} + +func (s *FromClauseContext) WHERE() antlr.TerminalNode { + return s.GetToken(MySqlParserWHERE, 0) +} + +func (s *FromClauseContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *FromClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FromClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FromClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterFromClause(s) + } +} + +func (s *FromClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitFromClause(s) + } +} + +func (p *MySqlParser) FromClause() (localctx IFromClauseContext) { + localctx = NewFromClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 284, MySqlParserRULE_fromClause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(4207) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserFROM { + { + p.SetState(4205) + p.Match(MySqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4206) + p.TableSources() + } + + } + p.SetState(4211) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserWHERE { + { + p.SetState(4209) + p.Match(MySqlParserWHERE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4210) + + var _x = p.expression(0) + + localctx.(*FromClauseContext).whereExpr = _x + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGroupByClauseContext is an interface to support dynamic dispatch. +type IGroupByClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GROUP() antlr.TerminalNode + BY() antlr.TerminalNode + AllGroupByItem() []IGroupByItemContext + GroupByItem(i int) IGroupByItemContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + WITH() antlr.TerminalNode + ROLLUP() antlr.TerminalNode + + // IsGroupByClauseContext differentiates from other interfaces. + IsGroupByClauseContext() +} + +type GroupByClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGroupByClauseContext() *GroupByClauseContext { + var p = new(GroupByClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_groupByClause + return p +} + +func InitEmptyGroupByClauseContext(p *GroupByClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_groupByClause +} + +func (*GroupByClauseContext) IsGroupByClauseContext() {} + +func NewGroupByClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GroupByClauseContext { + var p = new(GroupByClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_groupByClause + + return p +} + +func (s *GroupByClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *GroupByClauseContext) GROUP() antlr.TerminalNode { + return s.GetToken(MySqlParserGROUP, 0) +} + +func (s *GroupByClauseContext) BY() antlr.TerminalNode { + return s.GetToken(MySqlParserBY, 0) +} + +func (s *GroupByClauseContext) AllGroupByItem() []IGroupByItemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGroupByItemContext); ok { + len++ + } + } + + tst := make([]IGroupByItemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGroupByItemContext); ok { + tst[i] = t.(IGroupByItemContext) + i++ + } + } + + return tst +} + +func (s *GroupByClauseContext) GroupByItem(i int) IGroupByItemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGroupByItemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGroupByItemContext) +} + +func (s *GroupByClauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *GroupByClauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *GroupByClauseContext) WITH() antlr.TerminalNode { + return s.GetToken(MySqlParserWITH, 0) +} + +func (s *GroupByClauseContext) ROLLUP() antlr.TerminalNode { + return s.GetToken(MySqlParserROLLUP, 0) +} + +func (s *GroupByClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *GroupByClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *GroupByClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterGroupByClause(s) + } +} + +func (s *GroupByClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitGroupByClause(s) + } +} + +func (p *MySqlParser) GroupByClause() (localctx IGroupByClauseContext) { + localctx = NewGroupByClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 286, MySqlParserRULE_groupByClause) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4213) + p.Match(MySqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4214) + p.Match(MySqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4215) + p.GroupByItem() + } + p.SetState(4220) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 619, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(4216) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4217) + p.GroupByItem() + } + + } + p.SetState(4222) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 619, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(4225) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 620, p.GetParserRuleContext()) == 1 { + { + p.SetState(4223) + p.Match(MySqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4224) + p.Match(MySqlParserROLLUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHavingClauseContext is an interface to support dynamic dispatch. +type IHavingClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetHavingExpr returns the havingExpr rule contexts. + GetHavingExpr() IExpressionContext + + // SetHavingExpr sets the havingExpr rule contexts. + SetHavingExpr(IExpressionContext) + + // Getter signatures + HAVING() antlr.TerminalNode + Expression() IExpressionContext + + // IsHavingClauseContext differentiates from other interfaces. + IsHavingClauseContext() +} + +type HavingClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + havingExpr IExpressionContext +} + +func NewEmptyHavingClauseContext() *HavingClauseContext { + var p = new(HavingClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_havingClause + return p +} + +func InitEmptyHavingClauseContext(p *HavingClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_havingClause +} + +func (*HavingClauseContext) IsHavingClauseContext() {} + +func NewHavingClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *HavingClauseContext { + var p = new(HavingClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_havingClause + + return p +} + +func (s *HavingClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *HavingClauseContext) GetHavingExpr() IExpressionContext { return s.havingExpr } + +func (s *HavingClauseContext) SetHavingExpr(v IExpressionContext) { s.havingExpr = v } + +func (s *HavingClauseContext) HAVING() antlr.TerminalNode { + return s.GetToken(MySqlParserHAVING, 0) +} + +func (s *HavingClauseContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *HavingClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *HavingClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *HavingClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterHavingClause(s) + } +} + +func (s *HavingClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitHavingClause(s) + } +} + +func (p *MySqlParser) HavingClause() (localctx IHavingClauseContext) { + localctx = NewHavingClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 288, MySqlParserRULE_havingClause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4227) + p.Match(MySqlParserHAVING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4228) + + var _x = p.expression(0) + + localctx.(*HavingClauseContext).havingExpr = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWindowClauseContext is an interface to support dynamic dispatch. +type IWindowClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WINDOW() antlr.TerminalNode + AllWindowName() []IWindowNameContext + WindowName(i int) IWindowNameContext + AllAS() []antlr.TerminalNode + AS(i int) antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllWindowSpec() []IWindowSpecContext + WindowSpec(i int) IWindowSpecContext + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsWindowClauseContext differentiates from other interfaces. + IsWindowClauseContext() +} + +type WindowClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWindowClauseContext() *WindowClauseContext { + var p = new(WindowClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_windowClause + return p +} + +func InitEmptyWindowClauseContext(p *WindowClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_windowClause +} + +func (*WindowClauseContext) IsWindowClauseContext() {} + +func NewWindowClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WindowClauseContext { + var p = new(WindowClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_windowClause + + return p +} + +func (s *WindowClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *WindowClauseContext) WINDOW() antlr.TerminalNode { + return s.GetToken(MySqlParserWINDOW, 0) +} + +func (s *WindowClauseContext) AllWindowName() []IWindowNameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IWindowNameContext); ok { + len++ + } + } + + tst := make([]IWindowNameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IWindowNameContext); ok { + tst[i] = t.(IWindowNameContext) + i++ + } + } + + return tst +} + +func (s *WindowClauseContext) WindowName(i int) IWindowNameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWindowNameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IWindowNameContext) +} + +func (s *WindowClauseContext) AllAS() []antlr.TerminalNode { + return s.GetTokens(MySqlParserAS) +} + +func (s *WindowClauseContext) AS(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserAS, i) +} + +func (s *WindowClauseContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(MySqlParserLR_BRACKET) +} + +func (s *WindowClauseContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, i) +} + +func (s *WindowClauseContext) AllWindowSpec() []IWindowSpecContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IWindowSpecContext); ok { + len++ + } + } + + tst := make([]IWindowSpecContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IWindowSpecContext); ok { + tst[i] = t.(IWindowSpecContext) + i++ + } + } + + return tst +} + +func (s *WindowClauseContext) WindowSpec(i int) IWindowSpecContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWindowSpecContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IWindowSpecContext) +} + +func (s *WindowClauseContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(MySqlParserRR_BRACKET) +} + +func (s *WindowClauseContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, i) +} + +func (s *WindowClauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *WindowClauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *WindowClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *WindowClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *WindowClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterWindowClause(s) + } +} + +func (s *WindowClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitWindowClause(s) + } +} + +func (p *MySqlParser) WindowClause() (localctx IWindowClauseContext) { + localctx = NewWindowClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 290, MySqlParserRULE_windowClause) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4230) + p.Match(MySqlParserWINDOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4231) + p.WindowName() + } + { + p.SetState(4232) + p.Match(MySqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4233) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4234) + p.WindowSpec() + } + { + p.SetState(4235) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4245) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 621, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(4236) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4237) + p.WindowName() + } + { + p.SetState(4238) + p.Match(MySqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4239) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4240) + p.WindowSpec() + } + { + p.SetState(4241) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4247) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 621, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGroupByItemContext is an interface to support dynamic dispatch. +type IGroupByItemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetOrder returns the order token. + GetOrder() antlr.Token + + // SetOrder sets the order token. + SetOrder(antlr.Token) + + // Getter signatures + Expression() IExpressionContext + ASC() antlr.TerminalNode + DESC() antlr.TerminalNode + + // IsGroupByItemContext differentiates from other interfaces. + IsGroupByItemContext() +} + +type GroupByItemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + order antlr.Token +} + +func NewEmptyGroupByItemContext() *GroupByItemContext { + var p = new(GroupByItemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_groupByItem + return p +} + +func InitEmptyGroupByItemContext(p *GroupByItemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_groupByItem +} + +func (*GroupByItemContext) IsGroupByItemContext() {} + +func NewGroupByItemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GroupByItemContext { + var p = new(GroupByItemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_groupByItem + + return p +} + +func (s *GroupByItemContext) GetParser() antlr.Parser { return s.parser } + +func (s *GroupByItemContext) GetOrder() antlr.Token { return s.order } + +func (s *GroupByItemContext) SetOrder(v antlr.Token) { s.order = v } + +func (s *GroupByItemContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *GroupByItemContext) ASC() antlr.TerminalNode { + return s.GetToken(MySqlParserASC, 0) +} + +func (s *GroupByItemContext) DESC() antlr.TerminalNode { + return s.GetToken(MySqlParserDESC, 0) +} + +func (s *GroupByItemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *GroupByItemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *GroupByItemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterGroupByItem(s) + } +} + +func (s *GroupByItemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitGroupByItem(s) + } +} + +func (p *MySqlParser) GroupByItem() (localctx IGroupByItemContext) { + localctx = NewGroupByItemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 292, MySqlParserRULE_groupByItem) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4248) + p.expression(0) + } + p.SetState(4250) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 622, p.GetParserRuleContext()) == 1 { + { + p.SetState(4249) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*GroupByItemContext).order = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserASC || _la == MySqlParserDESC) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*GroupByItemContext).order = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILimitClauseContext is an interface to support dynamic dispatch. +type ILimitClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetOffset returns the offset rule contexts. + GetOffset() ILimitClauseAtomContext + + // GetLimit returns the limit rule contexts. + GetLimit() ILimitClauseAtomContext + + // SetOffset sets the offset rule contexts. + SetOffset(ILimitClauseAtomContext) + + // SetLimit sets the limit rule contexts. + SetLimit(ILimitClauseAtomContext) + + // Getter signatures + LIMIT() antlr.TerminalNode + OFFSET() antlr.TerminalNode + AllLimitClauseAtom() []ILimitClauseAtomContext + LimitClauseAtom(i int) ILimitClauseAtomContext + COMMA() antlr.TerminalNode + + // IsLimitClauseContext differentiates from other interfaces. + IsLimitClauseContext() +} + +type LimitClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + offset ILimitClauseAtomContext + limit ILimitClauseAtomContext +} + +func NewEmptyLimitClauseContext() *LimitClauseContext { + var p = new(LimitClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_limitClause + return p +} + +func InitEmptyLimitClauseContext(p *LimitClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_limitClause +} + +func (*LimitClauseContext) IsLimitClauseContext() {} + +func NewLimitClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LimitClauseContext { + var p = new(LimitClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_limitClause + + return p +} + +func (s *LimitClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *LimitClauseContext) GetOffset() ILimitClauseAtomContext { return s.offset } + +func (s *LimitClauseContext) GetLimit() ILimitClauseAtomContext { return s.limit } + +func (s *LimitClauseContext) SetOffset(v ILimitClauseAtomContext) { s.offset = v } + +func (s *LimitClauseContext) SetLimit(v ILimitClauseAtomContext) { s.limit = v } + +func (s *LimitClauseContext) LIMIT() antlr.TerminalNode { + return s.GetToken(MySqlParserLIMIT, 0) +} + +func (s *LimitClauseContext) OFFSET() antlr.TerminalNode { + return s.GetToken(MySqlParserOFFSET, 0) +} + +func (s *LimitClauseContext) AllLimitClauseAtom() []ILimitClauseAtomContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILimitClauseAtomContext); ok { + len++ + } + } + + tst := make([]ILimitClauseAtomContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILimitClauseAtomContext); ok { + tst[i] = t.(ILimitClauseAtomContext) + i++ + } + } + + return tst +} + +func (s *LimitClauseContext) LimitClauseAtom(i int) ILimitClauseAtomContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILimitClauseAtomContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILimitClauseAtomContext) +} + +func (s *LimitClauseContext) COMMA() antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, 0) +} + +func (s *LimitClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LimitClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *LimitClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterLimitClause(s) + } +} + +func (s *LimitClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitLimitClause(s) + } +} + +func (p *MySqlParser) LimitClause() (localctx ILimitClauseContext) { + localctx = NewLimitClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 294, MySqlParserRULE_limitClause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4252) + p.Match(MySqlParserLIMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4263) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 624, p.GetParserRuleContext()) { + case 1: + p.SetState(4256) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 623, p.GetParserRuleContext()) == 1 { + { + p.SetState(4253) + + var _x = p.LimitClauseAtom() + + localctx.(*LimitClauseContext).offset = _x + } + { + p.SetState(4254) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4258) + + var _x = p.LimitClauseAtom() + + localctx.(*LimitClauseContext).limit = _x + } + + case 2: + { + p.SetState(4259) + + var _x = p.LimitClauseAtom() + + localctx.(*LimitClauseContext).limit = _x + } + { + p.SetState(4260) + p.Match(MySqlParserOFFSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4261) + + var _x = p.LimitClauseAtom() + + localctx.(*LimitClauseContext).offset = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILimitClauseAtomContext is an interface to support dynamic dispatch. +type ILimitClauseAtomContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DecimalLiteral() IDecimalLiteralContext + MysqlVariable() IMysqlVariableContext + SimpleId() ISimpleIdContext + + // IsLimitClauseAtomContext differentiates from other interfaces. + IsLimitClauseAtomContext() +} + +type LimitClauseAtomContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLimitClauseAtomContext() *LimitClauseAtomContext { + var p = new(LimitClauseAtomContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_limitClauseAtom + return p +} + +func InitEmptyLimitClauseAtomContext(p *LimitClauseAtomContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_limitClauseAtom +} + +func (*LimitClauseAtomContext) IsLimitClauseAtomContext() {} + +func NewLimitClauseAtomContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LimitClauseAtomContext { + var p = new(LimitClauseAtomContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_limitClauseAtom + + return p +} + +func (s *LimitClauseAtomContext) GetParser() antlr.Parser { return s.parser } + +func (s *LimitClauseAtomContext) DecimalLiteral() IDecimalLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *LimitClauseAtomContext) MysqlVariable() IMysqlVariableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMysqlVariableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMysqlVariableContext) +} + +func (s *LimitClauseAtomContext) SimpleId() ISimpleIdContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimpleIdContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISimpleIdContext) +} + +func (s *LimitClauseAtomContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LimitClauseAtomContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *LimitClauseAtomContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterLimitClauseAtom(s) + } +} + +func (s *LimitClauseAtomContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitLimitClauseAtom(s) + } +} + +func (p *MySqlParser) LimitClauseAtom() (localctx ILimitClauseAtomContext) { + localctx = NewLimitClauseAtomContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 296, MySqlParserRULE_limitClauseAtom) + p.SetState(4268) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserZERO_DECIMAL, MySqlParserONE_DECIMAL, MySqlParserTWO_DECIMAL, MySqlParserDECIMAL_LITERAL, MySqlParserREAL_LITERAL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4265) + p.DecimalLiteral() + } + + case MySqlParserLOCAL_ID, MySqlParserGLOBAL_ID: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4266) + p.MysqlVariable() + } + + case MySqlParserARRAY, MySqlParserATTRIBUTE, MySqlParserBUCKETS, MySqlParserCONDITION, MySqlParserCURRENT, MySqlParserCURRENT_USER, MySqlParserDATABASE, MySqlParserDEFAULT, MySqlParserDIAGNOSTICS, MySqlParserEMPTY, MySqlParserENFORCED, MySqlParserEXCEPT, MySqlParserGROUP, MySqlParserIF, MySqlParserIGNORED, MySqlParserINSERT, MySqlParserLATERAL, MySqlParserLEFT, MySqlParserNUMBER, MySqlParserOPTIONAL, MySqlParserORDER, MySqlParserPRIMARY, MySqlParserREPEAT, MySqlParserREPLACE, MySqlParserRIGHT, MySqlParserSCHEMA, MySqlParserSKIP_QUERY_REWRITE, MySqlParserSTACKED, MySqlParserSTATEMENT, MySqlParserDATE, MySqlParserTIME, MySqlParserTIMESTAMP, MySqlParserDATETIME, MySqlParserYEAR, MySqlParserBINARY, MySqlParserTEXT, MySqlParserENUM, MySqlParserSERIAL, MySqlParserJSON_ARRAY, MySqlParserJSON_ARRAYAGG, MySqlParserJSON_ARRAY_APPEND, MySqlParserJSON_ARRAY_INSERT, MySqlParserJSON_CONTAINS, MySqlParserJSON_CONTAINS_PATH, MySqlParserJSON_DEPTH, MySqlParserJSON_EXTRACT, MySqlParserJSON_INSERT, MySqlParserJSON_KEYS, MySqlParserJSON_LENGTH, MySqlParserJSON_MERGE, MySqlParserJSON_MERGE_PATCH, MySqlParserJSON_MERGE_PRESERVE, MySqlParserJSON_OBJECT, MySqlParserJSON_OBJECTAGG, MySqlParserJSON_OVERLAPS, MySqlParserJSON_PRETTY, MySqlParserJSON_QUOTE, MySqlParserJSON_REMOVE, MySqlParserJSON_REPLACE, MySqlParserJSON_SCHEMA_VALID, MySqlParserJSON_SCHEMA_VALIDATION_REPORT, MySqlParserJSON_SEARCH, MySqlParserJSON_SET, MySqlParserJSON_STORAGE_FREE, MySqlParserJSON_STORAGE_SIZE, MySqlParserJSON_TABLE, MySqlParserJSON_TYPE, MySqlParserJSON_UNQUOTE, MySqlParserJSON_VALID, MySqlParserJSON_VALUE, MySqlParserNESTED, MySqlParserORDINALITY, MySqlParserPATH, MySqlParserAVG, MySqlParserBIT_AND, MySqlParserBIT_OR, MySqlParserBIT_XOR, MySqlParserCOUNT, MySqlParserCUME_DIST, MySqlParserDENSE_RANK, MySqlParserFIRST_VALUE, MySqlParserGROUP_CONCAT, MySqlParserLAG, MySqlParserLAST_VALUE, MySqlParserLEAD, MySqlParserMAX, MySqlParserMIN, MySqlParserNTILE, MySqlParserNTH_VALUE, MySqlParserPERCENT_RANK, MySqlParserRANK, MySqlParserROW_NUMBER, MySqlParserSTD, MySqlParserSTDDEV, MySqlParserSTDDEV_POP, MySqlParserSTDDEV_SAMP, MySqlParserSUM, MySqlParserVAR_POP, MySqlParserVAR_SAMP, MySqlParserVARIANCE, MySqlParserCURRENT_DATE, MySqlParserCURRENT_TIME, MySqlParserCURRENT_TIMESTAMP, MySqlParserLOCALTIME, MySqlParserCURDATE, MySqlParserCURTIME, MySqlParserDATE_ADD, MySqlParserDATE_SUB, MySqlParserLOCALTIMESTAMP, MySqlParserNOW, MySqlParserPOSITION, MySqlParserSUBSTR, MySqlParserSUBSTRING, MySqlParserSYSDATE, MySqlParserTRIM, MySqlParserUTC_DATE, MySqlParserUTC_TIME, MySqlParserUTC_TIMESTAMP, MySqlParserACCOUNT, MySqlParserACTION, MySqlParserAFTER, MySqlParserAGGREGATE, MySqlParserALGORITHM, MySqlParserANY, MySqlParserAT, MySqlParserAUTHORS, MySqlParserAUTOCOMMIT, MySqlParserAUTOEXTEND_SIZE, MySqlParserAUTO_INCREMENT, MySqlParserAVG_ROW_LENGTH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserBIT, MySqlParserBLOCK, MySqlParserBOOL, MySqlParserBOOLEAN, MySqlParserBTREE, MySqlParserCACHE, MySqlParserCASCADED, MySqlParserCHAIN, MySqlParserCHANGED, MySqlParserCHANNEL, MySqlParserCHECKSUM, MySqlParserPAGE_CHECKSUM, MySqlParserCIPHER, MySqlParserCLASS_ORIGIN, MySqlParserCLIENT, MySqlParserCLOSE, MySqlParserCLUSTERING, MySqlParserCOALESCE, MySqlParserCODE, MySqlParserCOLUMNS, MySqlParserCOLUMN_FORMAT, MySqlParserCOLUMN_NAME, MySqlParserCOMMENT, MySqlParserCOMMIT, MySqlParserCOMPACT, MySqlParserCOMPLETION, MySqlParserCOMPRESSED, MySqlParserCOMPRESSION, MySqlParserCONCURRENT, MySqlParserCONNECT, MySqlParserCONNECTION, MySqlParserCONSISTENT, MySqlParserCONSTRAINT_CATALOG, MySqlParserCONSTRAINT_SCHEMA, MySqlParserCONSTRAINT_NAME, MySqlParserCONTAINS, MySqlParserCONTEXT, MySqlParserCONTRIBUTORS, MySqlParserCOPY, MySqlParserCPU, MySqlParserCURSOR_NAME, MySqlParserDATA, MySqlParserDATAFILE, MySqlParserDEALLOCATE, MySqlParserDEFAULT_AUTH, MySqlParserDEFINER, MySqlParserDELAY_KEY_WRITE, MySqlParserDES_KEY_FILE, MySqlParserDIRECTORY, MySqlParserDISABLE, MySqlParserDISCARD, MySqlParserDISK, MySqlParserDO, MySqlParserDUMPFILE, MySqlParserDUPLICATE, MySqlParserDYNAMIC, MySqlParserENABLE, MySqlParserENCRYPTION, MySqlParserEND, MySqlParserENDS, MySqlParserENGINE, MySqlParserENGINES, MySqlParserERROR, MySqlParserERRORS, MySqlParserESCAPE, MySqlParserEVEN, MySqlParserEVENT, MySqlParserEVENTS, MySqlParserEVERY, MySqlParserEXCHANGE, MySqlParserEXCLUSIVE, MySqlParserEXPIRE, MySqlParserEXPORT, MySqlParserEXTENDED, MySqlParserEXTENT_SIZE, MySqlParserFAILED_LOGIN_ATTEMPTS, MySqlParserFAST, MySqlParserFAULTS, MySqlParserFIELDS, MySqlParserFILE_BLOCK_SIZE, MySqlParserFILTER, MySqlParserFIRST, MySqlParserFIXED, MySqlParserFLUSH, MySqlParserFOLLOWS, MySqlParserFOUND, MySqlParserFULL, MySqlParserFUNCTION, MySqlParserGENERAL, MySqlParserGLOBAL, MySqlParserGRANTS, MySqlParserGROUP_REPLICATION, MySqlParserHANDLER, MySqlParserHASH, MySqlParserHELP, MySqlParserHISTORY, MySqlParserHOST, MySqlParserHOSTS, MySqlParserIDENTIFIED, MySqlParserIGNORE_SERVER_IDS, MySqlParserIMPORT, MySqlParserINDEXES, MySqlParserINITIAL_SIZE, MySqlParserINPLACE, MySqlParserINSERT_METHOD, MySqlParserINSTALL, MySqlParserINSTANCE, MySqlParserINSTANT, MySqlParserINVISIBLE, MySqlParserINVOKER, MySqlParserIO, MySqlParserIO_THREAD, MySqlParserIPC, MySqlParserISOLATION, MySqlParserISSUER, MySqlParserJSON, MySqlParserKEY_BLOCK_SIZE, MySqlParserLANGUAGE, MySqlParserLAST, MySqlParserLEAVES, MySqlParserLESS, MySqlParserLEVEL, MySqlParserLIST, MySqlParserLOCAL, MySqlParserLOGFILE, MySqlParserLOGS, MySqlParserMASTER, MySqlParserMASTER_AUTO_POSITION, MySqlParserMASTER_CONNECT_RETRY, MySqlParserMASTER_DELAY, MySqlParserMASTER_HEARTBEAT_PERIOD, MySqlParserMASTER_HOST, MySqlParserMASTER_LOG_FILE, MySqlParserMASTER_LOG_POS, MySqlParserMASTER_PASSWORD, MySqlParserMASTER_PORT, MySqlParserMASTER_RETRY_COUNT, MySqlParserMASTER_SSL, MySqlParserMASTER_SSL_CA, MySqlParserMASTER_SSL_CAPATH, MySqlParserMASTER_SSL_CERT, MySqlParserMASTER_SSL_CIPHER, MySqlParserMASTER_SSL_CRL, MySqlParserMASTER_SSL_CRLPATH, MySqlParserMASTER_SSL_KEY, MySqlParserMASTER_TLS_VERSION, MySqlParserMASTER_USER, MySqlParserMAX_CONNECTIONS_PER_HOUR, MySqlParserMAX_QUERIES_PER_HOUR, MySqlParserMAX_ROWS, MySqlParserMAX_SIZE, MySqlParserMAX_UPDATES_PER_HOUR, MySqlParserMAX_USER_CONNECTIONS, MySqlParserMEDIUM, MySqlParserMEMBER, MySqlParserMERGE, MySqlParserMESSAGE_TEXT, MySqlParserMID, MySqlParserMIGRATE, MySqlParserMIN_ROWS, MySqlParserMODE, MySqlParserMODIFY, MySqlParserMUTEX, MySqlParserMYSQL, MySqlParserMYSQL_ERRNO, MySqlParserNAME, MySqlParserNAMES, MySqlParserNCHAR, MySqlParserNEVER, MySqlParserNEXT, MySqlParserNO, MySqlParserNOCOPY, MySqlParserNOWAIT, MySqlParserNODEGROUP, MySqlParserNONE, MySqlParserODBC, MySqlParserOFFLINE, MySqlParserOFFSET, MySqlParserOF, MySqlParserOJ, MySqlParserOLD_PASSWORD, MySqlParserONE, MySqlParserONLINE, MySqlParserONLY, MySqlParserOPEN, MySqlParserOPTIMIZER_COSTS, MySqlParserOPTIONS, MySqlParserOWNER, MySqlParserPACK_KEYS, MySqlParserPAGE, MySqlParserPARSER, MySqlParserPARTIAL, MySqlParserPARTITIONING, MySqlParserPARTITIONS, MySqlParserPASSWORD, MySqlParserPASSWORD_LOCK_TIME, MySqlParserPHASE, MySqlParserPLUGIN, MySqlParserPLUGIN_DIR, MySqlParserPLUGINS, MySqlParserPORT, MySqlParserPRECEDES, MySqlParserPREPARE, MySqlParserPRESERVE, MySqlParserPREV, MySqlParserPROCESSLIST, MySqlParserPROFILE, MySqlParserPROFILES, MySqlParserPROXY, MySqlParserQUERY, MySqlParserQUICK, MySqlParserREBUILD, MySqlParserRECOVER, MySqlParserRECURSIVE, MySqlParserREDO_BUFFER_SIZE, MySqlParserREDUNDANT, MySqlParserRELAY, MySqlParserRELAY_LOG_FILE, MySqlParserRELAY_LOG_POS, MySqlParserRELAYLOG, MySqlParserREMOVE, MySqlParserREORGANIZE, MySqlParserREPAIR, MySqlParserREPLICATE_DO_DB, MySqlParserREPLICATE_DO_TABLE, MySqlParserREPLICATE_IGNORE_DB, MySqlParserREPLICATE_IGNORE_TABLE, MySqlParserREPLICATE_REWRITE_DB, MySqlParserREPLICATE_WILD_DO_TABLE, MySqlParserREPLICATE_WILD_IGNORE_TABLE, MySqlParserREPLICATION, MySqlParserRESET, MySqlParserRESUME, MySqlParserRETURNED_SQLSTATE, MySqlParserRETURNING, MySqlParserRETURNS, MySqlParserREUSE, MySqlParserROLE, MySqlParserROLLBACK, MySqlParserROLLUP, MySqlParserROTATE, MySqlParserROW, MySqlParserROWS, MySqlParserROW_FORMAT, MySqlParserRTREE, MySqlParserSAVEPOINT, MySqlParserSCHEDULE, MySqlParserSECURITY, MySqlParserSERVER, MySqlParserSESSION, MySqlParserSHARE, MySqlParserSHARED, MySqlParserSIGNED, MySqlParserSIMPLE, MySqlParserSLAVE, MySqlParserSLOW, MySqlParserSNAPSHOT, MySqlParserSOCKET, MySqlParserSOME, MySqlParserSONAME, MySqlParserSOUNDS, MySqlParserSOURCE, MySqlParserSQL_AFTER_GTIDS, MySqlParserSQL_AFTER_MTS_GAPS, MySqlParserSQL_BEFORE_GTIDS, MySqlParserSQL_BUFFER_RESULT, MySqlParserSQL_CACHE, MySqlParserSQL_NO_CACHE, MySqlParserSQL_THREAD, MySqlParserSTART, MySqlParserSTARTS, MySqlParserSTATS_AUTO_RECALC, MySqlParserSTATS_PERSISTENT, MySqlParserSTATS_SAMPLE_PAGES, MySqlParserSTATUS, MySqlParserSTOP, MySqlParserSTORAGE, MySqlParserSTRING, MySqlParserSUBCLASS_ORIGIN, MySqlParserSUBJECT, MySqlParserSUBPARTITION, MySqlParserSUBPARTITIONS, MySqlParserSUSPEND, MySqlParserSWAPS, MySqlParserSWITCHES, MySqlParserTABLE_NAME, MySqlParserTABLESPACE, MySqlParserTABLE_TYPE, MySqlParserTEMPORARY, MySqlParserTEMPTABLE, MySqlParserTHAN, MySqlParserTRADITIONAL, MySqlParserTRANSACTION, MySqlParserTRANSACTIONAL, MySqlParserTRIGGERS, MySqlParserTRUNCATE, MySqlParserUNBOUNDED, MySqlParserUNDEFINED, MySqlParserUNDOFILE, MySqlParserUNDO_BUFFER_SIZE, MySqlParserUNINSTALL, MySqlParserUNKNOWN, MySqlParserUNTIL, MySqlParserUPGRADE, MySqlParserUSER, MySqlParserUSE_FRM, MySqlParserUSER_RESOURCES, MySqlParserVALIDATION, MySqlParserVALUE, MySqlParserVARIABLES, MySqlParserVIEW, MySqlParserVIRTUAL, MySqlParserVISIBLE, MySqlParserWAIT, MySqlParserWARNINGS, MySqlParserWITHOUT, MySqlParserWORK, MySqlParserWRAPPER, MySqlParserX509, MySqlParserXA, MySqlParserXML, MySqlParserYES, MySqlParserEUR, MySqlParserUSA, MySqlParserJIS, MySqlParserISO, MySqlParserINTERNAL, MySqlParserQUARTER, MySqlParserMONTH, MySqlParserDAY, MySqlParserHOUR, MySqlParserMINUTE, MySqlParserWEEK, MySqlParserSECOND, MySqlParserMICROSECOND, MySqlParserADMIN, MySqlParserAUDIT_ABORT_EXEMPT, MySqlParserAUDIT_ADMIN, MySqlParserAUTHENTICATION_POLICY_ADMIN, MySqlParserBACKUP_ADMIN, MySqlParserBINLOG_ADMIN, MySqlParserBINLOG_ENCRYPTION_ADMIN, MySqlParserCLONE_ADMIN, MySqlParserCONNECTION_ADMIN, MySqlParserENCRYPTION_KEY_ADMIN, MySqlParserEXECUTE, MySqlParserFILE, MySqlParserFIREWALL_ADMIN, MySqlParserFIREWALL_EXEMPT, MySqlParserFIREWALL_USER, MySqlParserGROUP_REPLICATION_ADMIN, MySqlParserINNODB_REDO_LOG_ARCHIVE, MySqlParserINVOKE, MySqlParserLAMBDA, MySqlParserNDB_STORED_USER, MySqlParserPASSWORDLESS_USER_ADMIN, MySqlParserPERSIST_RO_VARIABLES_ADMIN, MySqlParserPRIVILEGES, MySqlParserPROCESS, MySqlParserRELOAD, MySqlParserREPLICATION_APPLIER, MySqlParserREPLICATION_SLAVE_ADMIN, MySqlParserRESOURCE_GROUP_ADMIN, MySqlParserRESOURCE_GROUP_USER, MySqlParserROLE_ADMIN, MySqlParserROUTINE, MySqlParserS3, MySqlParserSESSION_VARIABLES_ADMIN, MySqlParserSET_USER_ID, MySqlParserSHOW_ROUTINE, MySqlParserSHUTDOWN, MySqlParserSUPER, MySqlParserSYSTEM_VARIABLES_ADMIN, MySqlParserTABLES, MySqlParserTABLE_ENCRYPTION_ADMIN, MySqlParserVERSION_TOKEN_ADMIN, MySqlParserXA_RECOVER_ADMIN, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserARCHIVE, MySqlParserBLACKHOLE, MySqlParserCSV, MySqlParserFEDERATED, MySqlParserINNODB, MySqlParserMEMORY, MySqlParserMRG_MYISAM, MySqlParserMYISAM, MySqlParserNDB, MySqlParserNDBCLUSTER, MySqlParserPERFORMANCE_SCHEMA, MySqlParserTOKUDB, MySqlParserREPEATABLE, MySqlParserCOMMITTED, MySqlParserUNCOMMITTED, MySqlParserSERIALIZABLE, MySqlParserGEOMETRYCOLLECTION, MySqlParserLINESTRING, MySqlParserMULTILINESTRING, MySqlParserMULTIPOINT, MySqlParserMULTIPOLYGON, MySqlParserPOINT, MySqlParserPOLYGON, MySqlParserABS, MySqlParserACOS, MySqlParserADDDATE, MySqlParserADDTIME, MySqlParserAES_DECRYPT, MySqlParserAES_ENCRYPT, MySqlParserAREA, MySqlParserASBINARY, MySqlParserASIN, MySqlParserASTEXT, MySqlParserASWKB, MySqlParserASWKT, MySqlParserASYMMETRIC_DECRYPT, MySqlParserASYMMETRIC_DERIVE, MySqlParserASYMMETRIC_ENCRYPT, MySqlParserASYMMETRIC_SIGN, MySqlParserASYMMETRIC_VERIFY, MySqlParserATAN, MySqlParserATAN2, MySqlParserBENCHMARK, MySqlParserBIN, MySqlParserBIT_COUNT, MySqlParserBIT_LENGTH, MySqlParserBUFFER, MySqlParserCATALOG_NAME, MySqlParserCEIL, MySqlParserCEILING, MySqlParserCENTROID, MySqlParserCHARACTER_LENGTH, MySqlParserCHARSET, MySqlParserCHAR_LENGTH, MySqlParserCOERCIBILITY, MySqlParserCOLLATION, MySqlParserCOMPRESS, MySqlParserCONCAT, MySqlParserCONCAT_WS, MySqlParserCONNECTION_ID, MySqlParserCONV, MySqlParserCONVERT_TZ, MySqlParserCOS, MySqlParserCOT, MySqlParserCRC32, MySqlParserCREATE_ASYMMETRIC_PRIV_KEY, MySqlParserCREATE_ASYMMETRIC_PUB_KEY, MySqlParserCREATE_DH_PARAMETERS, MySqlParserCREATE_DIGEST, MySqlParserCROSSES, MySqlParserDATEDIFF, MySqlParserDATE_FORMAT, MySqlParserDAYNAME, MySqlParserDAYOFMONTH, MySqlParserDAYOFWEEK, MySqlParserDAYOFYEAR, MySqlParserDECODE, MySqlParserDEGREES, MySqlParserDES_DECRYPT, MySqlParserDES_ENCRYPT, MySqlParserDIMENSION, MySqlParserDISJOINT, MySqlParserDISTANCE, MySqlParserELT, MySqlParserENCODE, MySqlParserENCRYPT, MySqlParserENDPOINT, MySqlParserENGINE_ATTRIBUTE, MySqlParserENVELOPE, MySqlParserEQUALS, MySqlParserEXP, MySqlParserEXPORT_SET, MySqlParserEXTERIORRING, MySqlParserEXTRACTVALUE, MySqlParserFIELD, MySqlParserFIND_IN_SET, MySqlParserFLOOR, MySqlParserFORMAT, MySqlParserFOUND_ROWS, MySqlParserFROM_BASE64, MySqlParserFROM_DAYS, MySqlParserFROM_UNIXTIME, MySqlParserGEOMCOLLFROMTEXT, MySqlParserGEOMCOLLFROMWKB, MySqlParserGEOMETRYCOLLECTIONFROMTEXT, MySqlParserGEOMETRYCOLLECTIONFROMWKB, MySqlParserGEOMETRYFROMTEXT, MySqlParserGEOMETRYFROMWKB, MySqlParserGEOMETRYN, MySqlParserGEOMETRYTYPE, MySqlParserGEOMFROMTEXT, MySqlParserGEOMFROMWKB, MySqlParserGET_FORMAT, MySqlParserGET_LOCK, MySqlParserGLENGTH, MySqlParserGREATEST, MySqlParserGTID_SUBSET, MySqlParserGTID_SUBTRACT, MySqlParserHEX, MySqlParserIFNULL, MySqlParserINET6_ATON, MySqlParserINET6_NTOA, MySqlParserINET_ATON, MySqlParserINET_NTOA, MySqlParserINSTR, MySqlParserINTERIORRINGN, MySqlParserINTERSECTS, MySqlParserISCLOSED, MySqlParserISEMPTY, MySqlParserISNULL, MySqlParserISSIMPLE, MySqlParserIS_FREE_LOCK, MySqlParserIS_IPV4, MySqlParserIS_IPV4_COMPAT, MySqlParserIS_IPV4_MAPPED, MySqlParserIS_IPV6, MySqlParserIS_USED_LOCK, MySqlParserLAST_INSERT_ID, MySqlParserLCASE, MySqlParserLEAST, MySqlParserLENGTH, MySqlParserLINEFROMTEXT, MySqlParserLINEFROMWKB, MySqlParserLINESTRINGFROMTEXT, MySqlParserLINESTRINGFROMWKB, MySqlParserLN, MySqlParserLOAD_FILE, MySqlParserLOCATE, MySqlParserLOG, MySqlParserLOG10, MySqlParserLOG2, MySqlParserLOWER, MySqlParserLPAD, MySqlParserLTRIM, MySqlParserMAKEDATE, MySqlParserMAKETIME, MySqlParserMAKE_SET, MySqlParserMASTER_POS_WAIT, MySqlParserMBRCONTAINS, MySqlParserMBRDISJOINT, MySqlParserMBREQUAL, MySqlParserMBRINTERSECTS, MySqlParserMBROVERLAPS, MySqlParserMBRTOUCHES, MySqlParserMBRWITHIN, MySqlParserMD5, MySqlParserMLINEFROMTEXT, MySqlParserMLINEFROMWKB, MySqlParserMONTHNAME, MySqlParserMPOINTFROMTEXT, MySqlParserMPOINTFROMWKB, MySqlParserMPOLYFROMTEXT, MySqlParserMPOLYFROMWKB, MySqlParserMULTILINESTRINGFROMTEXT, MySqlParserMULTILINESTRINGFROMWKB, MySqlParserMULTIPOINTFROMTEXT, MySqlParserMULTIPOINTFROMWKB, MySqlParserMULTIPOLYGONFROMTEXT, MySqlParserMULTIPOLYGONFROMWKB, MySqlParserNAME_CONST, MySqlParserNULLIF, MySqlParserNUMGEOMETRIES, MySqlParserNUMINTERIORRINGS, MySqlParserNUMPOINTS, MySqlParserOCT, MySqlParserOCTET_LENGTH, MySqlParserORD, MySqlParserOVERLAPS, MySqlParserPERIOD_ADD, MySqlParserPERIOD_DIFF, MySqlParserPI, MySqlParserPOINTFROMTEXT, MySqlParserPOINTFROMWKB, MySqlParserPOINTN, MySqlParserPOLYFROMTEXT, MySqlParserPOLYFROMWKB, MySqlParserPOLYGONFROMTEXT, MySqlParserPOLYGONFROMWKB, MySqlParserPOW, MySqlParserPOWER, MySqlParserQUOTE, MySqlParserRADIANS, MySqlParserRAND, MySqlParserRANDOM, MySqlParserRANDOM_BYTES, MySqlParserRELEASE_LOCK, MySqlParserREVERSE, MySqlParserROUND, MySqlParserROW_COUNT, MySqlParserRPAD, MySqlParserRTRIM, MySqlParserSEC_TO_TIME, MySqlParserSECONDARY_ENGINE_ATTRIBUTE, MySqlParserSESSION_USER, MySqlParserSHA, MySqlParserSHA1, MySqlParserSHA2, MySqlParserSCHEMA_NAME, MySqlParserSIGN, MySqlParserSIN, MySqlParserSLEEP, MySqlParserSOUNDEX, MySqlParserSQL_THREAD_WAIT_AFTER_GTIDS, MySqlParserSQRT, MySqlParserSRID, MySqlParserSTARTPOINT, MySqlParserSTRCMP, MySqlParserSTR_TO_DATE, MySqlParserST_AREA, MySqlParserST_ASBINARY, MySqlParserST_ASTEXT, MySqlParserST_ASWKB, MySqlParserST_ASWKT, MySqlParserST_BUFFER, MySqlParserST_CENTROID, MySqlParserST_CONTAINS, MySqlParserST_CROSSES, MySqlParserST_DIFFERENCE, MySqlParserST_DIMENSION, MySqlParserST_DISJOINT, MySqlParserST_DISTANCE, MySqlParserST_ENDPOINT, MySqlParserST_ENVELOPE, MySqlParserST_EQUALS, MySqlParserST_EXTERIORRING, MySqlParserST_GEOMCOLLFROMTEXT, MySqlParserST_GEOMCOLLFROMTXT, MySqlParserST_GEOMCOLLFROMWKB, MySqlParserST_GEOMETRYCOLLECTIONFROMTEXT, MySqlParserST_GEOMETRYCOLLECTIONFROMWKB, MySqlParserST_GEOMETRYFROMTEXT, MySqlParserST_GEOMETRYFROMWKB, MySqlParserST_GEOMETRYN, MySqlParserST_GEOMETRYTYPE, MySqlParserST_GEOMFROMTEXT, MySqlParserST_GEOMFROMWKB, MySqlParserST_INTERIORRINGN, MySqlParserST_INTERSECTION, MySqlParserST_INTERSECTS, MySqlParserST_ISCLOSED, MySqlParserST_ISEMPTY, MySqlParserST_ISSIMPLE, MySqlParserST_LINEFROMTEXT, MySqlParserST_LINEFROMWKB, MySqlParserST_LINESTRINGFROMTEXT, MySqlParserST_LINESTRINGFROMWKB, MySqlParserST_NUMGEOMETRIES, MySqlParserST_NUMINTERIORRING, MySqlParserST_NUMINTERIORRINGS, MySqlParserST_NUMPOINTS, MySqlParserST_OVERLAPS, MySqlParserST_POINTFROMTEXT, MySqlParserST_POINTFROMWKB, MySqlParserST_POINTN, MySqlParserST_POLYFROMTEXT, MySqlParserST_POLYFROMWKB, MySqlParserST_POLYGONFROMTEXT, MySqlParserST_POLYGONFROMWKB, MySqlParserST_SRID, MySqlParserST_STARTPOINT, MySqlParserST_SYMDIFFERENCE, MySqlParserST_TOUCHES, MySqlParserST_UNION, MySqlParserST_WITHIN, MySqlParserST_X, MySqlParserST_Y, MySqlParserSTRING_TO_VECTOR, MySqlParserSUBDATE, MySqlParserSUBSTRING_INDEX, MySqlParserSUBTIME, MySqlParserSYSTEM_USER, MySqlParserTAN, MySqlParserTIMEDIFF, MySqlParserTIMESTAMPADD, MySqlParserTIMESTAMPDIFF, MySqlParserTIME_FORMAT, MySqlParserTIME_TO_SEC, MySqlParserTOUCHES, MySqlParserTO_BASE64, MySqlParserTO_DAYS, MySqlParserTO_SECONDS, MySqlParserTP_CONNECTION_ADMIN, MySqlParserUCASE, MySqlParserUNCOMPRESS, MySqlParserUNCOMPRESSED_LENGTH, MySqlParserUNHEX, MySqlParserUNIX_TIMESTAMP, MySqlParserUPDATEXML, MySqlParserUPPER, MySqlParserUUID, MySqlParserUUID_SHORT, MySqlParserVALIDATE_PASSWORD_STRENGTH, MySqlParserVECTOR_DIM, MySqlParserVECTOR_TO_STRING, MySqlParserVERSION, MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS, MySqlParserWEEKDAY, MySqlParserWEEKOFYEAR, MySqlParserWEIGHT_STRING, MySqlParserWITHIN, MySqlParserYEARWEEK, MySqlParserY_FUNCTION, MySqlParserX_FUNCTION, MySqlParserMOD, MySqlParserID: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4267) + p.SimpleId() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStartTransactionContext is an interface to support dynamic dispatch. +type IStartTransactionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + START() antlr.TerminalNode + TRANSACTION() antlr.TerminalNode + AllTransactionMode() []ITransactionModeContext + TransactionMode(i int) ITransactionModeContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsStartTransactionContext differentiates from other interfaces. + IsStartTransactionContext() +} + +type StartTransactionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStartTransactionContext() *StartTransactionContext { + var p = new(StartTransactionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_startTransaction + return p +} + +func InitEmptyStartTransactionContext(p *StartTransactionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_startTransaction +} + +func (*StartTransactionContext) IsStartTransactionContext() {} + +func NewStartTransactionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StartTransactionContext { + var p = new(StartTransactionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_startTransaction + + return p +} + +func (s *StartTransactionContext) GetParser() antlr.Parser { return s.parser } + +func (s *StartTransactionContext) START() antlr.TerminalNode { + return s.GetToken(MySqlParserSTART, 0) +} + +func (s *StartTransactionContext) TRANSACTION() antlr.TerminalNode { + return s.GetToken(MySqlParserTRANSACTION, 0) +} + +func (s *StartTransactionContext) AllTransactionMode() []ITransactionModeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITransactionModeContext); ok { + len++ + } + } + + tst := make([]ITransactionModeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITransactionModeContext); ok { + tst[i] = t.(ITransactionModeContext) + i++ + } + } + + return tst +} + +func (s *StartTransactionContext) TransactionMode(i int) ITransactionModeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITransactionModeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITransactionModeContext) +} + +func (s *StartTransactionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *StartTransactionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *StartTransactionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *StartTransactionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *StartTransactionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterStartTransaction(s) + } +} + +func (s *StartTransactionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitStartTransaction(s) + } +} + +func (p *MySqlParser) StartTransaction() (localctx IStartTransactionContext) { + localctx = NewStartTransactionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 298, MySqlParserRULE_startTransaction) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4270) + p.Match(MySqlParserSTART) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4271) + p.Match(MySqlParserTRANSACTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4280) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 627, p.GetParserRuleContext()) == 1 { + { + p.SetState(4272) + p.TransactionMode() + } + p.SetState(4277) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(4273) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4274) + p.TransactionMode() + } + + p.SetState(4279) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBeginWorkContext is an interface to support dynamic dispatch. +type IBeginWorkContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BEGIN() antlr.TerminalNode + WORK() antlr.TerminalNode + + // IsBeginWorkContext differentiates from other interfaces. + IsBeginWorkContext() +} + +type BeginWorkContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBeginWorkContext() *BeginWorkContext { + var p = new(BeginWorkContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_beginWork + return p +} + +func InitEmptyBeginWorkContext(p *BeginWorkContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_beginWork +} + +func (*BeginWorkContext) IsBeginWorkContext() {} + +func NewBeginWorkContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BeginWorkContext { + var p = new(BeginWorkContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_beginWork + + return p +} + +func (s *BeginWorkContext) GetParser() antlr.Parser { return s.parser } + +func (s *BeginWorkContext) BEGIN() antlr.TerminalNode { + return s.GetToken(MySqlParserBEGIN, 0) +} + +func (s *BeginWorkContext) WORK() antlr.TerminalNode { + return s.GetToken(MySqlParserWORK, 0) +} + +func (s *BeginWorkContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *BeginWorkContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *BeginWorkContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterBeginWork(s) + } +} + +func (s *BeginWorkContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitBeginWork(s) + } +} + +func (p *MySqlParser) BeginWork() (localctx IBeginWorkContext) { + localctx = NewBeginWorkContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 300, MySqlParserRULE_beginWork) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4282) + p.Match(MySqlParserBEGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4284) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserWORK { + { + p.SetState(4283) + p.Match(MySqlParserWORK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICommitWorkContext is an interface to support dynamic dispatch. +type ICommitWorkContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetNochain returns the nochain token. + GetNochain() antlr.Token + + // GetNorelease returns the norelease token. + GetNorelease() antlr.Token + + // SetNochain sets the nochain token. + SetNochain(antlr.Token) + + // SetNorelease sets the norelease token. + SetNorelease(antlr.Token) + + // Getter signatures + COMMIT() antlr.TerminalNode + WORK() antlr.TerminalNode + AND() antlr.TerminalNode + CHAIN() antlr.TerminalNode + RELEASE() antlr.TerminalNode + AllNO() []antlr.TerminalNode + NO(i int) antlr.TerminalNode + + // IsCommitWorkContext differentiates from other interfaces. + IsCommitWorkContext() +} + +type CommitWorkContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + nochain antlr.Token + norelease antlr.Token +} + +func NewEmptyCommitWorkContext() *CommitWorkContext { + var p = new(CommitWorkContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_commitWork + return p +} + +func InitEmptyCommitWorkContext(p *CommitWorkContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_commitWork +} + +func (*CommitWorkContext) IsCommitWorkContext() {} + +func NewCommitWorkContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CommitWorkContext { + var p = new(CommitWorkContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_commitWork + + return p +} + +func (s *CommitWorkContext) GetParser() antlr.Parser { return s.parser } + +func (s *CommitWorkContext) GetNochain() antlr.Token { return s.nochain } + +func (s *CommitWorkContext) GetNorelease() antlr.Token { return s.norelease } + +func (s *CommitWorkContext) SetNochain(v antlr.Token) { s.nochain = v } + +func (s *CommitWorkContext) SetNorelease(v antlr.Token) { s.norelease = v } + +func (s *CommitWorkContext) COMMIT() antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMIT, 0) +} + +func (s *CommitWorkContext) WORK() antlr.TerminalNode { + return s.GetToken(MySqlParserWORK, 0) +} + +func (s *CommitWorkContext) AND() antlr.TerminalNode { + return s.GetToken(MySqlParserAND, 0) +} + +func (s *CommitWorkContext) CHAIN() antlr.TerminalNode { + return s.GetToken(MySqlParserCHAIN, 0) +} + +func (s *CommitWorkContext) RELEASE() antlr.TerminalNode { + return s.GetToken(MySqlParserRELEASE, 0) +} + +func (s *CommitWorkContext) AllNO() []antlr.TerminalNode { + return s.GetTokens(MySqlParserNO) +} + +func (s *CommitWorkContext) NO(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserNO, i) +} + +func (s *CommitWorkContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CommitWorkContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CommitWorkContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCommitWork(s) + } +} + +func (s *CommitWorkContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCommitWork(s) + } +} + +func (p *MySqlParser) CommitWork() (localctx ICommitWorkContext) { + localctx = NewCommitWorkContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 302, MySqlParserRULE_commitWork) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4286) + p.Match(MySqlParserCOMMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4288) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserWORK { + { + p.SetState(4287) + p.Match(MySqlParserWORK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4295) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserAND { + { + p.SetState(4290) + p.Match(MySqlParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4292) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserNO { + { + p.SetState(4291) + + var _m = p.Match(MySqlParserNO) + + localctx.(*CommitWorkContext).nochain = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4294) + p.Match(MySqlParserCHAIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4301) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 633, p.GetParserRuleContext()) == 1 { + p.SetState(4298) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserNO { + { + p.SetState(4297) + + var _m = p.Match(MySqlParserNO) + + localctx.(*CommitWorkContext).norelease = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4300) + p.Match(MySqlParserRELEASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRollbackWorkContext is an interface to support dynamic dispatch. +type IRollbackWorkContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetNochain returns the nochain token. + GetNochain() antlr.Token + + // GetNorelease returns the norelease token. + GetNorelease() antlr.Token + + // SetNochain sets the nochain token. + SetNochain(antlr.Token) + + // SetNorelease sets the norelease token. + SetNorelease(antlr.Token) + + // Getter signatures + ROLLBACK() antlr.TerminalNode + WORK() antlr.TerminalNode + AND() antlr.TerminalNode + CHAIN() antlr.TerminalNode + RELEASE() antlr.TerminalNode + AllNO() []antlr.TerminalNode + NO(i int) antlr.TerminalNode + + // IsRollbackWorkContext differentiates from other interfaces. + IsRollbackWorkContext() +} + +type RollbackWorkContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + nochain antlr.Token + norelease antlr.Token +} + +func NewEmptyRollbackWorkContext() *RollbackWorkContext { + var p = new(RollbackWorkContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_rollbackWork + return p +} + +func InitEmptyRollbackWorkContext(p *RollbackWorkContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_rollbackWork +} + +func (*RollbackWorkContext) IsRollbackWorkContext() {} + +func NewRollbackWorkContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RollbackWorkContext { + var p = new(RollbackWorkContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_rollbackWork + + return p +} + +func (s *RollbackWorkContext) GetParser() antlr.Parser { return s.parser } + +func (s *RollbackWorkContext) GetNochain() antlr.Token { return s.nochain } + +func (s *RollbackWorkContext) GetNorelease() antlr.Token { return s.norelease } + +func (s *RollbackWorkContext) SetNochain(v antlr.Token) { s.nochain = v } + +func (s *RollbackWorkContext) SetNorelease(v antlr.Token) { s.norelease = v } + +func (s *RollbackWorkContext) ROLLBACK() antlr.TerminalNode { + return s.GetToken(MySqlParserROLLBACK, 0) +} + +func (s *RollbackWorkContext) WORK() antlr.TerminalNode { + return s.GetToken(MySqlParserWORK, 0) +} + +func (s *RollbackWorkContext) AND() antlr.TerminalNode { + return s.GetToken(MySqlParserAND, 0) +} + +func (s *RollbackWorkContext) CHAIN() antlr.TerminalNode { + return s.GetToken(MySqlParserCHAIN, 0) +} + +func (s *RollbackWorkContext) RELEASE() antlr.TerminalNode { + return s.GetToken(MySqlParserRELEASE, 0) +} + +func (s *RollbackWorkContext) AllNO() []antlr.TerminalNode { + return s.GetTokens(MySqlParserNO) +} + +func (s *RollbackWorkContext) NO(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserNO, i) +} + +func (s *RollbackWorkContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RollbackWorkContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RollbackWorkContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterRollbackWork(s) + } +} + +func (s *RollbackWorkContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitRollbackWork(s) + } +} + +func (p *MySqlParser) RollbackWork() (localctx IRollbackWorkContext) { + localctx = NewRollbackWorkContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 304, MySqlParserRULE_rollbackWork) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4303) + p.Match(MySqlParserROLLBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4305) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserWORK { + { + p.SetState(4304) + p.Match(MySqlParserWORK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4312) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserAND { + { + p.SetState(4307) + p.Match(MySqlParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4309) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserNO { + { + p.SetState(4308) + + var _m = p.Match(MySqlParserNO) + + localctx.(*RollbackWorkContext).nochain = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4311) + p.Match(MySqlParserCHAIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4318) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 638, p.GetParserRuleContext()) == 1 { + p.SetState(4315) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserNO { + { + p.SetState(4314) + + var _m = p.Match(MySqlParserNO) + + localctx.(*RollbackWorkContext).norelease = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4317) + p.Match(MySqlParserRELEASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISavepointStatementContext is an interface to support dynamic dispatch. +type ISavepointStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SAVEPOINT() antlr.TerminalNode + Uid() IUidContext + + // IsSavepointStatementContext differentiates from other interfaces. + IsSavepointStatementContext() +} + +type SavepointStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySavepointStatementContext() *SavepointStatementContext { + var p = new(SavepointStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_savepointStatement + return p +} + +func InitEmptySavepointStatementContext(p *SavepointStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_savepointStatement +} + +func (*SavepointStatementContext) IsSavepointStatementContext() {} + +func NewSavepointStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SavepointStatementContext { + var p = new(SavepointStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_savepointStatement + + return p +} + +func (s *SavepointStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *SavepointStatementContext) SAVEPOINT() antlr.TerminalNode { + return s.GetToken(MySqlParserSAVEPOINT, 0) +} + +func (s *SavepointStatementContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *SavepointStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SavepointStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SavepointStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSavepointStatement(s) + } +} + +func (s *SavepointStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSavepointStatement(s) + } +} + +func (p *MySqlParser) SavepointStatement() (localctx ISavepointStatementContext) { + localctx = NewSavepointStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 306, MySqlParserRULE_savepointStatement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4320) + p.Match(MySqlParserSAVEPOINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4321) + p.Uid() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRollbackStatementContext is an interface to support dynamic dispatch. +type IRollbackStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ROLLBACK() antlr.TerminalNode + TO() antlr.TerminalNode + Uid() IUidContext + WORK() antlr.TerminalNode + SAVEPOINT() antlr.TerminalNode + + // IsRollbackStatementContext differentiates from other interfaces. + IsRollbackStatementContext() +} + +type RollbackStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRollbackStatementContext() *RollbackStatementContext { + var p = new(RollbackStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_rollbackStatement + return p +} + +func InitEmptyRollbackStatementContext(p *RollbackStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_rollbackStatement +} + +func (*RollbackStatementContext) IsRollbackStatementContext() {} + +func NewRollbackStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RollbackStatementContext { + var p = new(RollbackStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_rollbackStatement + + return p +} + +func (s *RollbackStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *RollbackStatementContext) ROLLBACK() antlr.TerminalNode { + return s.GetToken(MySqlParserROLLBACK, 0) +} + +func (s *RollbackStatementContext) TO() antlr.TerminalNode { + return s.GetToken(MySqlParserTO, 0) +} + +func (s *RollbackStatementContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *RollbackStatementContext) WORK() antlr.TerminalNode { + return s.GetToken(MySqlParserWORK, 0) +} + +func (s *RollbackStatementContext) SAVEPOINT() antlr.TerminalNode { + return s.GetToken(MySqlParserSAVEPOINT, 0) +} + +func (s *RollbackStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RollbackStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RollbackStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterRollbackStatement(s) + } +} + +func (s *RollbackStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitRollbackStatement(s) + } +} + +func (p *MySqlParser) RollbackStatement() (localctx IRollbackStatementContext) { + localctx = NewRollbackStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 308, MySqlParserRULE_rollbackStatement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4323) + p.Match(MySqlParserROLLBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4325) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserWORK { + { + p.SetState(4324) + p.Match(MySqlParserWORK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4327) + p.Match(MySqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4329) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 640, p.GetParserRuleContext()) == 1 { + { + p.SetState(4328) + p.Match(MySqlParserSAVEPOINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4331) + p.Uid() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReleaseStatementContext is an interface to support dynamic dispatch. +type IReleaseStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RELEASE() antlr.TerminalNode + SAVEPOINT() antlr.TerminalNode + Uid() IUidContext + + // IsReleaseStatementContext differentiates from other interfaces. + IsReleaseStatementContext() +} + +type ReleaseStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReleaseStatementContext() *ReleaseStatementContext { + var p = new(ReleaseStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_releaseStatement + return p +} + +func InitEmptyReleaseStatementContext(p *ReleaseStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_releaseStatement +} + +func (*ReleaseStatementContext) IsReleaseStatementContext() {} + +func NewReleaseStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReleaseStatementContext { + var p = new(ReleaseStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_releaseStatement + + return p +} + +func (s *ReleaseStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *ReleaseStatementContext) RELEASE() antlr.TerminalNode { + return s.GetToken(MySqlParserRELEASE, 0) +} + +func (s *ReleaseStatementContext) SAVEPOINT() antlr.TerminalNode { + return s.GetToken(MySqlParserSAVEPOINT, 0) +} + +func (s *ReleaseStatementContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *ReleaseStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ReleaseStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ReleaseStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterReleaseStatement(s) + } +} + +func (s *ReleaseStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitReleaseStatement(s) + } +} + +func (p *MySqlParser) ReleaseStatement() (localctx IReleaseStatementContext) { + localctx = NewReleaseStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 310, MySqlParserRULE_releaseStatement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4333) + p.Match(MySqlParserRELEASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4334) + p.Match(MySqlParserSAVEPOINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4335) + p.Uid() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILockTablesContext is an interface to support dynamic dispatch. +type ILockTablesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LOCK() antlr.TerminalNode + AllLockTableElement() []ILockTableElementContext + LockTableElement(i int) ILockTableElementContext + TABLE() antlr.TerminalNode + TABLES() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + WaitNowaitClause() IWaitNowaitClauseContext + + // IsLockTablesContext differentiates from other interfaces. + IsLockTablesContext() +} + +type LockTablesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLockTablesContext() *LockTablesContext { + var p = new(LockTablesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_lockTables + return p +} + +func InitEmptyLockTablesContext(p *LockTablesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_lockTables +} + +func (*LockTablesContext) IsLockTablesContext() {} + +func NewLockTablesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LockTablesContext { + var p = new(LockTablesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_lockTables + + return p +} + +func (s *LockTablesContext) GetParser() antlr.Parser { return s.parser } + +func (s *LockTablesContext) LOCK() antlr.TerminalNode { + return s.GetToken(MySqlParserLOCK, 0) +} + +func (s *LockTablesContext) AllLockTableElement() []ILockTableElementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILockTableElementContext); ok { + len++ + } + } + + tst := make([]ILockTableElementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILockTableElementContext); ok { + tst[i] = t.(ILockTableElementContext) + i++ + } + } + + return tst +} + +func (s *LockTablesContext) LockTableElement(i int) ILockTableElementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILockTableElementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILockTableElementContext) +} + +func (s *LockTablesContext) TABLE() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLE, 0) +} + +func (s *LockTablesContext) TABLES() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLES, 0) +} + +func (s *LockTablesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *LockTablesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *LockTablesContext) WaitNowaitClause() IWaitNowaitClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWaitNowaitClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWaitNowaitClauseContext) +} + +func (s *LockTablesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LockTablesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *LockTablesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterLockTables(s) + } +} + +func (s *LockTablesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitLockTables(s) + } +} + +func (p *MySqlParser) LockTables() (localctx ILockTablesContext) { + localctx = NewLockTablesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 312, MySqlParserRULE_lockTables) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4337) + p.Match(MySqlParserLOCK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4338) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserTABLE || _la == MySqlParserTABLES) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(4339) + p.LockTableElement() + } + p.SetState(4344) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(4340) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4341) + p.LockTableElement() + } + + p.SetState(4346) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(4348) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserNOWAIT || _la == MySqlParserWAIT { + { + p.SetState(4347) + p.WaitNowaitClause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUnlockTablesContext is an interface to support dynamic dispatch. +type IUnlockTablesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNLOCK() antlr.TerminalNode + TABLES() antlr.TerminalNode + + // IsUnlockTablesContext differentiates from other interfaces. + IsUnlockTablesContext() +} + +type UnlockTablesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUnlockTablesContext() *UnlockTablesContext { + var p = new(UnlockTablesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_unlockTables + return p +} + +func InitEmptyUnlockTablesContext(p *UnlockTablesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_unlockTables +} + +func (*UnlockTablesContext) IsUnlockTablesContext() {} + +func NewUnlockTablesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnlockTablesContext { + var p = new(UnlockTablesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_unlockTables + + return p +} + +func (s *UnlockTablesContext) GetParser() antlr.Parser { return s.parser } + +func (s *UnlockTablesContext) UNLOCK() antlr.TerminalNode { + return s.GetToken(MySqlParserUNLOCK, 0) +} + +func (s *UnlockTablesContext) TABLES() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLES, 0) +} + +func (s *UnlockTablesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UnlockTablesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *UnlockTablesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterUnlockTables(s) + } +} + +func (s *UnlockTablesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitUnlockTables(s) + } +} + +func (p *MySqlParser) UnlockTables() (localctx IUnlockTablesContext) { + localctx = NewUnlockTablesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 314, MySqlParserRULE_unlockTables) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4350) + p.Match(MySqlParserUNLOCK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4351) + p.Match(MySqlParserTABLES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISetAutocommitStatementContext is an interface to support dynamic dispatch. +type ISetAutocommitStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetAutocommitValue returns the autocommitValue token. + GetAutocommitValue() antlr.Token + + // SetAutocommitValue sets the autocommitValue token. + SetAutocommitValue(antlr.Token) + + // Getter signatures + SET() antlr.TerminalNode + AUTOCOMMIT() antlr.TerminalNode + EQUAL_SYMBOL() antlr.TerminalNode + ZERO_DECIMAL() antlr.TerminalNode + ONE_DECIMAL() antlr.TerminalNode + + // IsSetAutocommitStatementContext differentiates from other interfaces. + IsSetAutocommitStatementContext() +} + +type SetAutocommitStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + autocommitValue antlr.Token +} + +func NewEmptySetAutocommitStatementContext() *SetAutocommitStatementContext { + var p = new(SetAutocommitStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_setAutocommitStatement + return p +} + +func InitEmptySetAutocommitStatementContext(p *SetAutocommitStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_setAutocommitStatement +} + +func (*SetAutocommitStatementContext) IsSetAutocommitStatementContext() {} + +func NewSetAutocommitStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SetAutocommitStatementContext { + var p = new(SetAutocommitStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_setAutocommitStatement + + return p +} + +func (s *SetAutocommitStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *SetAutocommitStatementContext) GetAutocommitValue() antlr.Token { return s.autocommitValue } + +func (s *SetAutocommitStatementContext) SetAutocommitValue(v antlr.Token) { s.autocommitValue = v } + +func (s *SetAutocommitStatementContext) SET() antlr.TerminalNode { + return s.GetToken(MySqlParserSET, 0) +} + +func (s *SetAutocommitStatementContext) AUTOCOMMIT() antlr.TerminalNode { + return s.GetToken(MySqlParserAUTOCOMMIT, 0) +} + +func (s *SetAutocommitStatementContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *SetAutocommitStatementContext) ZERO_DECIMAL() antlr.TerminalNode { + return s.GetToken(MySqlParserZERO_DECIMAL, 0) +} + +func (s *SetAutocommitStatementContext) ONE_DECIMAL() antlr.TerminalNode { + return s.GetToken(MySqlParserONE_DECIMAL, 0) +} + +func (s *SetAutocommitStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SetAutocommitStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SetAutocommitStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSetAutocommitStatement(s) + } +} + +func (s *SetAutocommitStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSetAutocommitStatement(s) + } +} + +func (p *MySqlParser) SetAutocommitStatement() (localctx ISetAutocommitStatementContext) { + localctx = NewSetAutocommitStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 316, MySqlParserRULE_setAutocommitStatement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4353) + p.Match(MySqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4354) + p.Match(MySqlParserAUTOCOMMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4355) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4356) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*SetAutocommitStatementContext).autocommitValue = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserZERO_DECIMAL || _la == MySqlParserONE_DECIMAL) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*SetAutocommitStatementContext).autocommitValue = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISetTransactionStatementContext is an interface to support dynamic dispatch. +type ISetTransactionStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetTransactionContext returns the transactionContext token. + GetTransactionContext() antlr.Token + + // SetTransactionContext sets the transactionContext token. + SetTransactionContext(antlr.Token) + + // Getter signatures + SET() antlr.TerminalNode + TRANSACTION() antlr.TerminalNode + AllTransactionOption() []ITransactionOptionContext + TransactionOption(i int) ITransactionOptionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + GLOBAL() antlr.TerminalNode + SESSION() antlr.TerminalNode + + // IsSetTransactionStatementContext differentiates from other interfaces. + IsSetTransactionStatementContext() +} + +type SetTransactionStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + transactionContext antlr.Token +} + +func NewEmptySetTransactionStatementContext() *SetTransactionStatementContext { + var p = new(SetTransactionStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_setTransactionStatement + return p +} + +func InitEmptySetTransactionStatementContext(p *SetTransactionStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_setTransactionStatement +} + +func (*SetTransactionStatementContext) IsSetTransactionStatementContext() {} + +func NewSetTransactionStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SetTransactionStatementContext { + var p = new(SetTransactionStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_setTransactionStatement + + return p +} + +func (s *SetTransactionStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *SetTransactionStatementContext) GetTransactionContext() antlr.Token { + return s.transactionContext +} + +func (s *SetTransactionStatementContext) SetTransactionContext(v antlr.Token) { + s.transactionContext = v +} + +func (s *SetTransactionStatementContext) SET() antlr.TerminalNode { + return s.GetToken(MySqlParserSET, 0) +} + +func (s *SetTransactionStatementContext) TRANSACTION() antlr.TerminalNode { + return s.GetToken(MySqlParserTRANSACTION, 0) +} + +func (s *SetTransactionStatementContext) AllTransactionOption() []ITransactionOptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITransactionOptionContext); ok { + len++ + } + } + + tst := make([]ITransactionOptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITransactionOptionContext); ok { + tst[i] = t.(ITransactionOptionContext) + i++ + } + } + + return tst +} + +func (s *SetTransactionStatementContext) TransactionOption(i int) ITransactionOptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITransactionOptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITransactionOptionContext) +} + +func (s *SetTransactionStatementContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *SetTransactionStatementContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *SetTransactionStatementContext) GLOBAL() antlr.TerminalNode { + return s.GetToken(MySqlParserGLOBAL, 0) +} + +func (s *SetTransactionStatementContext) SESSION() antlr.TerminalNode { + return s.GetToken(MySqlParserSESSION, 0) +} + +func (s *SetTransactionStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SetTransactionStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SetTransactionStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSetTransactionStatement(s) + } +} + +func (s *SetTransactionStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSetTransactionStatement(s) + } +} + +func (p *MySqlParser) SetTransactionStatement() (localctx ISetTransactionStatementContext) { + localctx = NewSetTransactionStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 318, MySqlParserRULE_setTransactionStatement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4358) + p.Match(MySqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4360) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserGLOBAL || _la == MySqlParserSESSION { + { + p.SetState(4359) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*SetTransactionStatementContext).transactionContext = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserGLOBAL || _la == MySqlParserSESSION) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*SetTransactionStatementContext).transactionContext = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(4362) + p.Match(MySqlParserTRANSACTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4363) + p.TransactionOption() + } + p.SetState(4368) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(4364) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4365) + p.TransactionOption() + } + + p.SetState(4370) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITransactionModeContext is an interface to support dynamic dispatch. +type ITransactionModeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH() antlr.TerminalNode + CONSISTENT() antlr.TerminalNode + SNAPSHOT() antlr.TerminalNode + READ() antlr.TerminalNode + WRITE() antlr.TerminalNode + ONLY() antlr.TerminalNode + + // IsTransactionModeContext differentiates from other interfaces. + IsTransactionModeContext() +} + +type TransactionModeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTransactionModeContext() *TransactionModeContext { + var p = new(TransactionModeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_transactionMode + return p +} + +func InitEmptyTransactionModeContext(p *TransactionModeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_transactionMode +} + +func (*TransactionModeContext) IsTransactionModeContext() {} + +func NewTransactionModeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TransactionModeContext { + var p = new(TransactionModeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_transactionMode + + return p +} + +func (s *TransactionModeContext) GetParser() antlr.Parser { return s.parser } + +func (s *TransactionModeContext) WITH() antlr.TerminalNode { + return s.GetToken(MySqlParserWITH, 0) +} + +func (s *TransactionModeContext) CONSISTENT() antlr.TerminalNode { + return s.GetToken(MySqlParserCONSISTENT, 0) +} + +func (s *TransactionModeContext) SNAPSHOT() antlr.TerminalNode { + return s.GetToken(MySqlParserSNAPSHOT, 0) +} + +func (s *TransactionModeContext) READ() antlr.TerminalNode { + return s.GetToken(MySqlParserREAD, 0) +} + +func (s *TransactionModeContext) WRITE() antlr.TerminalNode { + return s.GetToken(MySqlParserWRITE, 0) +} + +func (s *TransactionModeContext) ONLY() antlr.TerminalNode { + return s.GetToken(MySqlParserONLY, 0) +} + +func (s *TransactionModeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TransactionModeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TransactionModeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTransactionMode(s) + } +} + +func (s *TransactionModeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTransactionMode(s) + } +} + +func (p *MySqlParser) TransactionMode() (localctx ITransactionModeContext) { + localctx = NewTransactionModeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 320, MySqlParserRULE_transactionMode) + p.SetState(4378) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 645, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4371) + p.Match(MySqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4372) + p.Match(MySqlParserCONSISTENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4373) + p.Match(MySqlParserSNAPSHOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4374) + p.Match(MySqlParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4375) + p.Match(MySqlParserWRITE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4376) + p.Match(MySqlParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4377) + p.Match(MySqlParserONLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILockTableElementContext is an interface to support dynamic dispatch. +type ILockTableElementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TableName() ITableNameContext + LockAction() ILockActionContext + Uid() IUidContext + AS() antlr.TerminalNode + + // IsLockTableElementContext differentiates from other interfaces. + IsLockTableElementContext() +} + +type LockTableElementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLockTableElementContext() *LockTableElementContext { + var p = new(LockTableElementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_lockTableElement + return p +} + +func InitEmptyLockTableElementContext(p *LockTableElementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_lockTableElement +} + +func (*LockTableElementContext) IsLockTableElementContext() {} + +func NewLockTableElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LockTableElementContext { + var p = new(LockTableElementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_lockTableElement + + return p +} + +func (s *LockTableElementContext) GetParser() antlr.Parser { return s.parser } + +func (s *LockTableElementContext) TableName() ITableNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableNameContext) +} + +func (s *LockTableElementContext) LockAction() ILockActionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILockActionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILockActionContext) +} + +func (s *LockTableElementContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *LockTableElementContext) AS() antlr.TerminalNode { + return s.GetToken(MySqlParserAS, 0) +} + +func (s *LockTableElementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LockTableElementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *LockTableElementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterLockTableElement(s) + } +} + +func (s *LockTableElementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitLockTableElement(s) + } +} + +func (p *MySqlParser) LockTableElement() (localctx ILockTableElementContext) { + localctx = NewLockTableElementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 322, MySqlParserRULE_lockTableElement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4380) + p.TableName() + } + p.SetState(4385) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513126400) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-34354363873) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-2199023255553) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-5764611921080745985) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-8796126576641) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-32651097298436097) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-18014398517872129) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-137438953601) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-44473063500156929) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-129) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-12289) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&-1) != 0) || ((int64((_la-1128)) & ^0x3f) == 0 && ((int64(1)<<(_la-1128))&8627683329) != 0) { + p.SetState(4382) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserAS { + { + p.SetState(4381) + p.Match(MySqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4384) + p.Uid() + } + + } + { + p.SetState(4387) + p.LockAction() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILockActionContext is an interface to support dynamic dispatch. +type ILockActionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + READ() antlr.TerminalNode + LOCAL() antlr.TerminalNode + WRITE() antlr.TerminalNode + LOW_PRIORITY() antlr.TerminalNode + + // IsLockActionContext differentiates from other interfaces. + IsLockActionContext() +} + +type LockActionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLockActionContext() *LockActionContext { + var p = new(LockActionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_lockAction + return p +} + +func InitEmptyLockActionContext(p *LockActionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_lockAction +} + +func (*LockActionContext) IsLockActionContext() {} + +func NewLockActionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LockActionContext { + var p = new(LockActionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_lockAction + + return p +} + +func (s *LockActionContext) GetParser() antlr.Parser { return s.parser } + +func (s *LockActionContext) READ() antlr.TerminalNode { + return s.GetToken(MySqlParserREAD, 0) +} + +func (s *LockActionContext) LOCAL() antlr.TerminalNode { + return s.GetToken(MySqlParserLOCAL, 0) +} + +func (s *LockActionContext) WRITE() antlr.TerminalNode { + return s.GetToken(MySqlParserWRITE, 0) +} + +func (s *LockActionContext) LOW_PRIORITY() antlr.TerminalNode { + return s.GetToken(MySqlParserLOW_PRIORITY, 0) +} + +func (s *LockActionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LockActionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *LockActionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterLockAction(s) + } +} + +func (s *LockActionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitLockAction(s) + } +} + +func (p *MySqlParser) LockAction() (localctx ILockActionContext) { + localctx = NewLockActionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 324, MySqlParserRULE_lockAction) + var _la int + + p.SetState(4397) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserREAD: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4389) + p.Match(MySqlParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4391) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserLOCAL { + { + p.SetState(4390) + p.Match(MySqlParserLOCAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case MySqlParserLOW_PRIORITY, MySqlParserWRITE: + p.EnterOuterAlt(localctx, 2) + p.SetState(4394) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserLOW_PRIORITY { + { + p.SetState(4393) + p.Match(MySqlParserLOW_PRIORITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4396) + p.Match(MySqlParserWRITE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITransactionOptionContext is an interface to support dynamic dispatch. +type ITransactionOptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ISOLATION() antlr.TerminalNode + LEVEL() antlr.TerminalNode + TransactionLevel() ITransactionLevelContext + READ() antlr.TerminalNode + WRITE() antlr.TerminalNode + ONLY() antlr.TerminalNode + + // IsTransactionOptionContext differentiates from other interfaces. + IsTransactionOptionContext() +} + +type TransactionOptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTransactionOptionContext() *TransactionOptionContext { + var p = new(TransactionOptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_transactionOption + return p +} + +func InitEmptyTransactionOptionContext(p *TransactionOptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_transactionOption +} + +func (*TransactionOptionContext) IsTransactionOptionContext() {} + +func NewTransactionOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TransactionOptionContext { + var p = new(TransactionOptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_transactionOption + + return p +} + +func (s *TransactionOptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *TransactionOptionContext) ISOLATION() antlr.TerminalNode { + return s.GetToken(MySqlParserISOLATION, 0) +} + +func (s *TransactionOptionContext) LEVEL() antlr.TerminalNode { + return s.GetToken(MySqlParserLEVEL, 0) +} + +func (s *TransactionOptionContext) TransactionLevel() ITransactionLevelContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITransactionLevelContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITransactionLevelContext) +} + +func (s *TransactionOptionContext) READ() antlr.TerminalNode { + return s.GetToken(MySqlParserREAD, 0) +} + +func (s *TransactionOptionContext) WRITE() antlr.TerminalNode { + return s.GetToken(MySqlParserWRITE, 0) +} + +func (s *TransactionOptionContext) ONLY() antlr.TerminalNode { + return s.GetToken(MySqlParserONLY, 0) +} + +func (s *TransactionOptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TransactionOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TransactionOptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTransactionOption(s) + } +} + +func (s *TransactionOptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTransactionOption(s) + } +} + +func (p *MySqlParser) TransactionOption() (localctx ITransactionOptionContext) { + localctx = NewTransactionOptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 326, MySqlParserRULE_transactionOption) + p.SetState(4406) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 651, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4399) + p.Match(MySqlParserISOLATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4400) + p.Match(MySqlParserLEVEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4401) + p.TransactionLevel() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4402) + p.Match(MySqlParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4403) + p.Match(MySqlParserWRITE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4404) + p.Match(MySqlParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4405) + p.Match(MySqlParserONLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITransactionLevelContext is an interface to support dynamic dispatch. +type ITransactionLevelContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REPEATABLE() antlr.TerminalNode + READ() antlr.TerminalNode + COMMITTED() antlr.TerminalNode + UNCOMMITTED() antlr.TerminalNode + SERIALIZABLE() antlr.TerminalNode + + // IsTransactionLevelContext differentiates from other interfaces. + IsTransactionLevelContext() +} + +type TransactionLevelContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTransactionLevelContext() *TransactionLevelContext { + var p = new(TransactionLevelContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_transactionLevel + return p +} + +func InitEmptyTransactionLevelContext(p *TransactionLevelContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_transactionLevel +} + +func (*TransactionLevelContext) IsTransactionLevelContext() {} + +func NewTransactionLevelContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TransactionLevelContext { + var p = new(TransactionLevelContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_transactionLevel + + return p +} + +func (s *TransactionLevelContext) GetParser() antlr.Parser { return s.parser } + +func (s *TransactionLevelContext) REPEATABLE() antlr.TerminalNode { + return s.GetToken(MySqlParserREPEATABLE, 0) +} + +func (s *TransactionLevelContext) READ() antlr.TerminalNode { + return s.GetToken(MySqlParserREAD, 0) +} + +func (s *TransactionLevelContext) COMMITTED() antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMITTED, 0) +} + +func (s *TransactionLevelContext) UNCOMMITTED() antlr.TerminalNode { + return s.GetToken(MySqlParserUNCOMMITTED, 0) +} + +func (s *TransactionLevelContext) SERIALIZABLE() antlr.TerminalNode { + return s.GetToken(MySqlParserSERIALIZABLE, 0) +} + +func (s *TransactionLevelContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TransactionLevelContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TransactionLevelContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTransactionLevel(s) + } +} + +func (s *TransactionLevelContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTransactionLevel(s) + } +} + +func (p *MySqlParser) TransactionLevel() (localctx ITransactionLevelContext) { + localctx = NewTransactionLevelContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 328, MySqlParserRULE_transactionLevel) + p.SetState(4415) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 652, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4408) + p.Match(MySqlParserREPEATABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4409) + p.Match(MySqlParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4410) + p.Match(MySqlParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4411) + p.Match(MySqlParserCOMMITTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4412) + p.Match(MySqlParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4413) + p.Match(MySqlParserUNCOMMITTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4414) + p.Match(MySqlParserSERIALIZABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IChangeMasterContext is an interface to support dynamic dispatch. +type IChangeMasterContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHANGE() antlr.TerminalNode + MASTER() antlr.TerminalNode + TO() antlr.TerminalNode + AllMasterOption() []IMasterOptionContext + MasterOption(i int) IMasterOptionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + ChannelOption() IChannelOptionContext + + // IsChangeMasterContext differentiates from other interfaces. + IsChangeMasterContext() +} + +type ChangeMasterContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyChangeMasterContext() *ChangeMasterContext { + var p = new(ChangeMasterContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_changeMaster + return p +} + +func InitEmptyChangeMasterContext(p *ChangeMasterContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_changeMaster +} + +func (*ChangeMasterContext) IsChangeMasterContext() {} + +func NewChangeMasterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ChangeMasterContext { + var p = new(ChangeMasterContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_changeMaster + + return p +} + +func (s *ChangeMasterContext) GetParser() antlr.Parser { return s.parser } + +func (s *ChangeMasterContext) CHANGE() antlr.TerminalNode { + return s.GetToken(MySqlParserCHANGE, 0) +} + +func (s *ChangeMasterContext) MASTER() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER, 0) +} + +func (s *ChangeMasterContext) TO() antlr.TerminalNode { + return s.GetToken(MySqlParserTO, 0) +} + +func (s *ChangeMasterContext) AllMasterOption() []IMasterOptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IMasterOptionContext); ok { + len++ + } + } + + tst := make([]IMasterOptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IMasterOptionContext); ok { + tst[i] = t.(IMasterOptionContext) + i++ + } + } + + return tst +} + +func (s *ChangeMasterContext) MasterOption(i int) IMasterOptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMasterOptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IMasterOptionContext) +} + +func (s *ChangeMasterContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *ChangeMasterContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *ChangeMasterContext) ChannelOption() IChannelOptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IChannelOptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IChannelOptionContext) +} + +func (s *ChangeMasterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ChangeMasterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ChangeMasterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterChangeMaster(s) + } +} + +func (s *ChangeMasterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitChangeMaster(s) + } +} + +func (p *MySqlParser) ChangeMaster() (localctx IChangeMasterContext) { + localctx = NewChangeMasterContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 330, MySqlParserRULE_changeMaster) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4417) + p.Match(MySqlParserCHANGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4418) + p.Match(MySqlParserMASTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4419) + p.Match(MySqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4420) + p.MasterOption() + } + p.SetState(4425) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(4421) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4422) + p.MasterOption() + } + + p.SetState(4427) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(4429) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserFOR { + { + p.SetState(4428) + p.ChannelOption() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IChangeReplicationFilterContext is an interface to support dynamic dispatch. +type IChangeReplicationFilterContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHANGE() antlr.TerminalNode + REPLICATION() antlr.TerminalNode + FILTER() antlr.TerminalNode + AllReplicationFilter() []IReplicationFilterContext + ReplicationFilter(i int) IReplicationFilterContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsChangeReplicationFilterContext differentiates from other interfaces. + IsChangeReplicationFilterContext() +} + +type ChangeReplicationFilterContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyChangeReplicationFilterContext() *ChangeReplicationFilterContext { + var p = new(ChangeReplicationFilterContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_changeReplicationFilter + return p +} + +func InitEmptyChangeReplicationFilterContext(p *ChangeReplicationFilterContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_changeReplicationFilter +} + +func (*ChangeReplicationFilterContext) IsChangeReplicationFilterContext() {} + +func NewChangeReplicationFilterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ChangeReplicationFilterContext { + var p = new(ChangeReplicationFilterContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_changeReplicationFilter + + return p +} + +func (s *ChangeReplicationFilterContext) GetParser() antlr.Parser { return s.parser } + +func (s *ChangeReplicationFilterContext) CHANGE() antlr.TerminalNode { + return s.GetToken(MySqlParserCHANGE, 0) +} + +func (s *ChangeReplicationFilterContext) REPLICATION() antlr.TerminalNode { + return s.GetToken(MySqlParserREPLICATION, 0) +} + +func (s *ChangeReplicationFilterContext) FILTER() antlr.TerminalNode { + return s.GetToken(MySqlParserFILTER, 0) +} + +func (s *ChangeReplicationFilterContext) AllReplicationFilter() []IReplicationFilterContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IReplicationFilterContext); ok { + len++ + } + } + + tst := make([]IReplicationFilterContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IReplicationFilterContext); ok { + tst[i] = t.(IReplicationFilterContext) + i++ + } + } + + return tst +} + +func (s *ChangeReplicationFilterContext) ReplicationFilter(i int) IReplicationFilterContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReplicationFilterContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IReplicationFilterContext) +} + +func (s *ChangeReplicationFilterContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *ChangeReplicationFilterContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *ChangeReplicationFilterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ChangeReplicationFilterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ChangeReplicationFilterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterChangeReplicationFilter(s) + } +} + +func (s *ChangeReplicationFilterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitChangeReplicationFilter(s) + } +} + +func (p *MySqlParser) ChangeReplicationFilter() (localctx IChangeReplicationFilterContext) { + localctx = NewChangeReplicationFilterContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 332, MySqlParserRULE_changeReplicationFilter) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4431) + p.Match(MySqlParserCHANGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4432) + p.Match(MySqlParserREPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4433) + p.Match(MySqlParserFILTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4434) + p.ReplicationFilter() + } + p.SetState(4439) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(4435) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4436) + p.ReplicationFilter() + } + + p.SetState(4441) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPurgeBinaryLogsContext is an interface to support dynamic dispatch. +type IPurgeBinaryLogsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPurgeFormat returns the purgeFormat token. + GetPurgeFormat() antlr.Token + + // GetFileName returns the fileName token. + GetFileName() antlr.Token + + // GetTimeValue returns the timeValue token. + GetTimeValue() antlr.Token + + // SetPurgeFormat sets the purgeFormat token. + SetPurgeFormat(antlr.Token) + + // SetFileName sets the fileName token. + SetFileName(antlr.Token) + + // SetTimeValue sets the timeValue token. + SetTimeValue(antlr.Token) + + // Getter signatures + PURGE() antlr.TerminalNode + LOGS() antlr.TerminalNode + BINARY() antlr.TerminalNode + MASTER() antlr.TerminalNode + TO() antlr.TerminalNode + BEFORE() antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + + // IsPurgeBinaryLogsContext differentiates from other interfaces. + IsPurgeBinaryLogsContext() +} + +type PurgeBinaryLogsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + purgeFormat antlr.Token + fileName antlr.Token + timeValue antlr.Token +} + +func NewEmptyPurgeBinaryLogsContext() *PurgeBinaryLogsContext { + var p = new(PurgeBinaryLogsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_purgeBinaryLogs + return p +} + +func InitEmptyPurgeBinaryLogsContext(p *PurgeBinaryLogsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_purgeBinaryLogs +} + +func (*PurgeBinaryLogsContext) IsPurgeBinaryLogsContext() {} + +func NewPurgeBinaryLogsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PurgeBinaryLogsContext { + var p = new(PurgeBinaryLogsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_purgeBinaryLogs + + return p +} + +func (s *PurgeBinaryLogsContext) GetParser() antlr.Parser { return s.parser } + +func (s *PurgeBinaryLogsContext) GetPurgeFormat() antlr.Token { return s.purgeFormat } + +func (s *PurgeBinaryLogsContext) GetFileName() antlr.Token { return s.fileName } + +func (s *PurgeBinaryLogsContext) GetTimeValue() antlr.Token { return s.timeValue } + +func (s *PurgeBinaryLogsContext) SetPurgeFormat(v antlr.Token) { s.purgeFormat = v } + +func (s *PurgeBinaryLogsContext) SetFileName(v antlr.Token) { s.fileName = v } + +func (s *PurgeBinaryLogsContext) SetTimeValue(v antlr.Token) { s.timeValue = v } + +func (s *PurgeBinaryLogsContext) PURGE() antlr.TerminalNode { + return s.GetToken(MySqlParserPURGE, 0) +} + +func (s *PurgeBinaryLogsContext) LOGS() antlr.TerminalNode { + return s.GetToken(MySqlParserLOGS, 0) +} + +func (s *PurgeBinaryLogsContext) BINARY() antlr.TerminalNode { + return s.GetToken(MySqlParserBINARY, 0) +} + +func (s *PurgeBinaryLogsContext) MASTER() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER, 0) +} + +func (s *PurgeBinaryLogsContext) TO() antlr.TerminalNode { + return s.GetToken(MySqlParserTO, 0) +} + +func (s *PurgeBinaryLogsContext) BEFORE() antlr.TerminalNode { + return s.GetToken(MySqlParserBEFORE, 0) +} + +func (s *PurgeBinaryLogsContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *PurgeBinaryLogsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PurgeBinaryLogsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PurgeBinaryLogsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterPurgeBinaryLogs(s) + } +} + +func (s *PurgeBinaryLogsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitPurgeBinaryLogs(s) + } +} + +func (p *MySqlParser) PurgeBinaryLogs() (localctx IPurgeBinaryLogsContext) { + localctx = NewPurgeBinaryLogsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 334, MySqlParserRULE_purgeBinaryLogs) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4442) + p.Match(MySqlParserPURGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4443) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*PurgeBinaryLogsContext).purgeFormat = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserBINARY || _la == MySqlParserMASTER) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*PurgeBinaryLogsContext).purgeFormat = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(4444) + p.Match(MySqlParserLOGS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4449) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserTO: + { + p.SetState(4445) + p.Match(MySqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4446) + + var _m = p.Match(MySqlParserSTRING_LITERAL) + + localctx.(*PurgeBinaryLogsContext).fileName = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserBEFORE: + { + p.SetState(4447) + p.Match(MySqlParserBEFORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4448) + + var _m = p.Match(MySqlParserSTRING_LITERAL) + + localctx.(*PurgeBinaryLogsContext).timeValue = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IResetMasterContext is an interface to support dynamic dispatch. +type IResetMasterContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RESET() antlr.TerminalNode + MASTER() antlr.TerminalNode + + // IsResetMasterContext differentiates from other interfaces. + IsResetMasterContext() +} + +type ResetMasterContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyResetMasterContext() *ResetMasterContext { + var p = new(ResetMasterContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_resetMaster + return p +} + +func InitEmptyResetMasterContext(p *ResetMasterContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_resetMaster +} + +func (*ResetMasterContext) IsResetMasterContext() {} + +func NewResetMasterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ResetMasterContext { + var p = new(ResetMasterContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_resetMaster + + return p +} + +func (s *ResetMasterContext) GetParser() antlr.Parser { return s.parser } + +func (s *ResetMasterContext) RESET() antlr.TerminalNode { + return s.GetToken(MySqlParserRESET, 0) +} + +func (s *ResetMasterContext) MASTER() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER, 0) +} + +func (s *ResetMasterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ResetMasterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ResetMasterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterResetMaster(s) + } +} + +func (s *ResetMasterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitResetMaster(s) + } +} + +func (p *MySqlParser) ResetMaster() (localctx IResetMasterContext) { + localctx = NewResetMasterContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 336, MySqlParserRULE_resetMaster) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4451) + p.Match(MySqlParserRESET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4452) + p.Match(MySqlParserMASTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IResetSlaveContext is an interface to support dynamic dispatch. +type IResetSlaveContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RESET() antlr.TerminalNode + SLAVE() antlr.TerminalNode + ALL() antlr.TerminalNode + ChannelOption() IChannelOptionContext + + // IsResetSlaveContext differentiates from other interfaces. + IsResetSlaveContext() +} + +type ResetSlaveContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyResetSlaveContext() *ResetSlaveContext { + var p = new(ResetSlaveContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_resetSlave + return p +} + +func InitEmptyResetSlaveContext(p *ResetSlaveContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_resetSlave +} + +func (*ResetSlaveContext) IsResetSlaveContext() {} + +func NewResetSlaveContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ResetSlaveContext { + var p = new(ResetSlaveContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_resetSlave + + return p +} + +func (s *ResetSlaveContext) GetParser() antlr.Parser { return s.parser } + +func (s *ResetSlaveContext) RESET() antlr.TerminalNode { + return s.GetToken(MySqlParserRESET, 0) +} + +func (s *ResetSlaveContext) SLAVE() antlr.TerminalNode { + return s.GetToken(MySqlParserSLAVE, 0) +} + +func (s *ResetSlaveContext) ALL() antlr.TerminalNode { + return s.GetToken(MySqlParserALL, 0) +} + +func (s *ResetSlaveContext) ChannelOption() IChannelOptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IChannelOptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IChannelOptionContext) +} + +func (s *ResetSlaveContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ResetSlaveContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ResetSlaveContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterResetSlave(s) + } +} + +func (s *ResetSlaveContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitResetSlave(s) + } +} + +func (p *MySqlParser) ResetSlave() (localctx IResetSlaveContext) { + localctx = NewResetSlaveContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 338, MySqlParserRULE_resetSlave) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4454) + p.Match(MySqlParserRESET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4455) + p.Match(MySqlParserSLAVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4457) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserALL { + { + p.SetState(4456) + p.Match(MySqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4460) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserFOR { + { + p.SetState(4459) + p.ChannelOption() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStartSlaveContext is an interface to support dynamic dispatch. +type IStartSlaveContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + START() antlr.TerminalNode + SLAVE() antlr.TerminalNode + AllThreadType() []IThreadTypeContext + ThreadType(i int) IThreadTypeContext + UNTIL() antlr.TerminalNode + UntilOption() IUntilOptionContext + AllConnectionOption() []IConnectionOptionContext + ConnectionOption(i int) IConnectionOptionContext + ChannelOption() IChannelOptionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsStartSlaveContext differentiates from other interfaces. + IsStartSlaveContext() +} + +type StartSlaveContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStartSlaveContext() *StartSlaveContext { + var p = new(StartSlaveContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_startSlave + return p +} + +func InitEmptyStartSlaveContext(p *StartSlaveContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_startSlave +} + +func (*StartSlaveContext) IsStartSlaveContext() {} + +func NewStartSlaveContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StartSlaveContext { + var p = new(StartSlaveContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_startSlave + + return p +} + +func (s *StartSlaveContext) GetParser() antlr.Parser { return s.parser } + +func (s *StartSlaveContext) START() antlr.TerminalNode { + return s.GetToken(MySqlParserSTART, 0) +} + +func (s *StartSlaveContext) SLAVE() antlr.TerminalNode { + return s.GetToken(MySqlParserSLAVE, 0) +} + +func (s *StartSlaveContext) AllThreadType() []IThreadTypeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IThreadTypeContext); ok { + len++ + } + } + + tst := make([]IThreadTypeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IThreadTypeContext); ok { + tst[i] = t.(IThreadTypeContext) + i++ + } + } + + return tst +} + +func (s *StartSlaveContext) ThreadType(i int) IThreadTypeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IThreadTypeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IThreadTypeContext) +} + +func (s *StartSlaveContext) UNTIL() antlr.TerminalNode { + return s.GetToken(MySqlParserUNTIL, 0) +} + +func (s *StartSlaveContext) UntilOption() IUntilOptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUntilOptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUntilOptionContext) +} + +func (s *StartSlaveContext) AllConnectionOption() []IConnectionOptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IConnectionOptionContext); ok { + len++ + } + } + + tst := make([]IConnectionOptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IConnectionOptionContext); ok { + tst[i] = t.(IConnectionOptionContext) + i++ + } + } + + return tst +} + +func (s *StartSlaveContext) ConnectionOption(i int) IConnectionOptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConnectionOptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IConnectionOptionContext) +} + +func (s *StartSlaveContext) ChannelOption() IChannelOptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IChannelOptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IChannelOptionContext) +} + +func (s *StartSlaveContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *StartSlaveContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *StartSlaveContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *StartSlaveContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *StartSlaveContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterStartSlave(s) + } +} + +func (s *StartSlaveContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitStartSlave(s) + } +} + +func (p *MySqlParser) StartSlave() (localctx IStartSlaveContext) { + localctx = NewStartSlaveContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 340, MySqlParserRULE_startSlave) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4462) + p.Match(MySqlParserSTART) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4463) + p.Match(MySqlParserSLAVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4472) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserIO_THREAD || _la == MySqlParserSQL_THREAD { + { + p.SetState(4464) + p.ThreadType() + } + p.SetState(4469) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(4465) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4466) + p.ThreadType() + } + + p.SetState(4471) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + p.SetState(4476) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserUNTIL { + { + p.SetState(4474) + p.Match(MySqlParserUNTIL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4475) + p.UntilOption() + } + + } + p.SetState(4481) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserDEFAULT_AUTH || _la == MySqlParserPASSWORD || _la == MySqlParserPLUGIN_DIR || _la == MySqlParserUSER { + { + p.SetState(4478) + p.ConnectionOption() + } + + p.SetState(4483) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(4485) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserFOR { + { + p.SetState(4484) + p.ChannelOption() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStopSlaveContext is an interface to support dynamic dispatch. +type IStopSlaveContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + STOP() antlr.TerminalNode + SLAVE() antlr.TerminalNode + AllThreadType() []IThreadTypeContext + ThreadType(i int) IThreadTypeContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsStopSlaveContext differentiates from other interfaces. + IsStopSlaveContext() +} + +type StopSlaveContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStopSlaveContext() *StopSlaveContext { + var p = new(StopSlaveContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_stopSlave + return p +} + +func InitEmptyStopSlaveContext(p *StopSlaveContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_stopSlave +} + +func (*StopSlaveContext) IsStopSlaveContext() {} + +func NewStopSlaveContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StopSlaveContext { + var p = new(StopSlaveContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_stopSlave + + return p +} + +func (s *StopSlaveContext) GetParser() antlr.Parser { return s.parser } + +func (s *StopSlaveContext) STOP() antlr.TerminalNode { + return s.GetToken(MySqlParserSTOP, 0) +} + +func (s *StopSlaveContext) SLAVE() antlr.TerminalNode { + return s.GetToken(MySqlParserSLAVE, 0) +} + +func (s *StopSlaveContext) AllThreadType() []IThreadTypeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IThreadTypeContext); ok { + len++ + } + } + + tst := make([]IThreadTypeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IThreadTypeContext); ok { + tst[i] = t.(IThreadTypeContext) + i++ + } + } + + return tst +} + +func (s *StopSlaveContext) ThreadType(i int) IThreadTypeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IThreadTypeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IThreadTypeContext) +} + +func (s *StopSlaveContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *StopSlaveContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *StopSlaveContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *StopSlaveContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *StopSlaveContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterStopSlave(s) + } +} + +func (s *StopSlaveContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitStopSlave(s) + } +} + +func (p *MySqlParser) StopSlave() (localctx IStopSlaveContext) { + localctx = NewStopSlaveContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 342, MySqlParserRULE_stopSlave) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4487) + p.Match(MySqlParserSTOP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4488) + p.Match(MySqlParserSLAVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4497) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserIO_THREAD || _la == MySqlParserSQL_THREAD { + { + p.SetState(4489) + p.ThreadType() + } + p.SetState(4494) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(4490) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4491) + p.ThreadType() + } + + p.SetState(4496) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStartGroupReplicationContext is an interface to support dynamic dispatch. +type IStartGroupReplicationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + START() antlr.TerminalNode + GROUP_REPLICATION() antlr.TerminalNode + + // IsStartGroupReplicationContext differentiates from other interfaces. + IsStartGroupReplicationContext() +} + +type StartGroupReplicationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStartGroupReplicationContext() *StartGroupReplicationContext { + var p = new(StartGroupReplicationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_startGroupReplication + return p +} + +func InitEmptyStartGroupReplicationContext(p *StartGroupReplicationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_startGroupReplication +} + +func (*StartGroupReplicationContext) IsStartGroupReplicationContext() {} + +func NewStartGroupReplicationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StartGroupReplicationContext { + var p = new(StartGroupReplicationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_startGroupReplication + + return p +} + +func (s *StartGroupReplicationContext) GetParser() antlr.Parser { return s.parser } + +func (s *StartGroupReplicationContext) START() antlr.TerminalNode { + return s.GetToken(MySqlParserSTART, 0) +} + +func (s *StartGroupReplicationContext) GROUP_REPLICATION() antlr.TerminalNode { + return s.GetToken(MySqlParserGROUP_REPLICATION, 0) +} + +func (s *StartGroupReplicationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *StartGroupReplicationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *StartGroupReplicationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterStartGroupReplication(s) + } +} + +func (s *StartGroupReplicationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitStartGroupReplication(s) + } +} + +func (p *MySqlParser) StartGroupReplication() (localctx IStartGroupReplicationContext) { + localctx = NewStartGroupReplicationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 344, MySqlParserRULE_startGroupReplication) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4499) + p.Match(MySqlParserSTART) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4500) + p.Match(MySqlParserGROUP_REPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStopGroupReplicationContext is an interface to support dynamic dispatch. +type IStopGroupReplicationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + STOP() antlr.TerminalNode + GROUP_REPLICATION() antlr.TerminalNode + + // IsStopGroupReplicationContext differentiates from other interfaces. + IsStopGroupReplicationContext() +} + +type StopGroupReplicationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStopGroupReplicationContext() *StopGroupReplicationContext { + var p = new(StopGroupReplicationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_stopGroupReplication + return p +} + +func InitEmptyStopGroupReplicationContext(p *StopGroupReplicationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_stopGroupReplication +} + +func (*StopGroupReplicationContext) IsStopGroupReplicationContext() {} + +func NewStopGroupReplicationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StopGroupReplicationContext { + var p = new(StopGroupReplicationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_stopGroupReplication + + return p +} + +func (s *StopGroupReplicationContext) GetParser() antlr.Parser { return s.parser } + +func (s *StopGroupReplicationContext) STOP() antlr.TerminalNode { + return s.GetToken(MySqlParserSTOP, 0) +} + +func (s *StopGroupReplicationContext) GROUP_REPLICATION() antlr.TerminalNode { + return s.GetToken(MySqlParserGROUP_REPLICATION, 0) +} + +func (s *StopGroupReplicationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *StopGroupReplicationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *StopGroupReplicationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterStopGroupReplication(s) + } +} + +func (s *StopGroupReplicationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitStopGroupReplication(s) + } +} + +func (p *MySqlParser) StopGroupReplication() (localctx IStopGroupReplicationContext) { + localctx = NewStopGroupReplicationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 346, MySqlParserRULE_stopGroupReplication) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4502) + p.Match(MySqlParserSTOP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4503) + p.Match(MySqlParserGROUP_REPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMasterOptionContext is an interface to support dynamic dispatch. +type IMasterOptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsMasterOptionContext differentiates from other interfaces. + IsMasterOptionContext() +} + +type MasterOptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMasterOptionContext() *MasterOptionContext { + var p = new(MasterOptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_masterOption + return p +} + +func InitEmptyMasterOptionContext(p *MasterOptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_masterOption +} + +func (*MasterOptionContext) IsMasterOptionContext() {} + +func NewMasterOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MasterOptionContext { + var p = new(MasterOptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_masterOption + + return p +} + +func (s *MasterOptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *MasterOptionContext) CopyAll(ctx *MasterOptionContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *MasterOptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MasterOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type MasterStringOptionContext struct { + MasterOptionContext +} + +func NewMasterStringOptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MasterStringOptionContext { + var p = new(MasterStringOptionContext) + + InitEmptyMasterOptionContext(&p.MasterOptionContext) + p.parser = parser + p.CopyAll(ctx.(*MasterOptionContext)) + + return p +} + +func (s *MasterStringOptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MasterStringOptionContext) StringMasterOption() IStringMasterOptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringMasterOptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringMasterOptionContext) +} + +func (s *MasterStringOptionContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *MasterStringOptionContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *MasterStringOptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterMasterStringOption(s) + } +} + +func (s *MasterStringOptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitMasterStringOption(s) + } +} + +type MasterRealOptionContext struct { + MasterOptionContext +} + +func NewMasterRealOptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MasterRealOptionContext { + var p = new(MasterRealOptionContext) + + InitEmptyMasterOptionContext(&p.MasterOptionContext) + p.parser = parser + p.CopyAll(ctx.(*MasterOptionContext)) + + return p +} + +func (s *MasterRealOptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MasterRealOptionContext) MASTER_HEARTBEAT_PERIOD() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER_HEARTBEAT_PERIOD, 0) +} + +func (s *MasterRealOptionContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *MasterRealOptionContext) REAL_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserREAL_LITERAL, 0) +} + +func (s *MasterRealOptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterMasterRealOption(s) + } +} + +func (s *MasterRealOptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitMasterRealOption(s) + } +} + +type MasterBoolOptionContext struct { + MasterOptionContext + boolVal antlr.Token +} + +func NewMasterBoolOptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MasterBoolOptionContext { + var p = new(MasterBoolOptionContext) + + InitEmptyMasterOptionContext(&p.MasterOptionContext) + p.parser = parser + p.CopyAll(ctx.(*MasterOptionContext)) + + return p +} + +func (s *MasterBoolOptionContext) GetBoolVal() antlr.Token { return s.boolVal } + +func (s *MasterBoolOptionContext) SetBoolVal(v antlr.Token) { s.boolVal = v } + +func (s *MasterBoolOptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MasterBoolOptionContext) BoolMasterOption() IBoolMasterOptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBoolMasterOptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBoolMasterOptionContext) +} + +func (s *MasterBoolOptionContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *MasterBoolOptionContext) ZERO_DECIMAL() antlr.TerminalNode { + return s.GetToken(MySqlParserZERO_DECIMAL, 0) +} + +func (s *MasterBoolOptionContext) ONE_DECIMAL() antlr.TerminalNode { + return s.GetToken(MySqlParserONE_DECIMAL, 0) +} + +func (s *MasterBoolOptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterMasterBoolOption(s) + } +} + +func (s *MasterBoolOptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitMasterBoolOption(s) + } +} + +type MasterUidListOptionContext struct { + MasterOptionContext +} + +func NewMasterUidListOptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MasterUidListOptionContext { + var p = new(MasterUidListOptionContext) + + InitEmptyMasterOptionContext(&p.MasterOptionContext) + p.parser = parser + p.CopyAll(ctx.(*MasterOptionContext)) + + return p +} + +func (s *MasterUidListOptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MasterUidListOptionContext) IGNORE_SERVER_IDS() antlr.TerminalNode { + return s.GetToken(MySqlParserIGNORE_SERVER_IDS, 0) +} + +func (s *MasterUidListOptionContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *MasterUidListOptionContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *MasterUidListOptionContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *MasterUidListOptionContext) AllUid() []IUidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUidContext); ok { + len++ + } + } + + tst := make([]IUidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUidContext); ok { + tst[i] = t.(IUidContext) + i++ + } + } + + return tst +} + +func (s *MasterUidListOptionContext) Uid(i int) IUidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *MasterUidListOptionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *MasterUidListOptionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *MasterUidListOptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterMasterUidListOption(s) + } +} + +func (s *MasterUidListOptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitMasterUidListOption(s) + } +} + +type MasterDecimalOptionContext struct { + MasterOptionContext +} + +func NewMasterDecimalOptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MasterDecimalOptionContext { + var p = new(MasterDecimalOptionContext) + + InitEmptyMasterOptionContext(&p.MasterOptionContext) + p.parser = parser + p.CopyAll(ctx.(*MasterOptionContext)) + + return p +} + +func (s *MasterDecimalOptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MasterDecimalOptionContext) DecimalMasterOption() IDecimalMasterOptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalMasterOptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecimalMasterOptionContext) +} + +func (s *MasterDecimalOptionContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *MasterDecimalOptionContext) DecimalLiteral() IDecimalLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *MasterDecimalOptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterMasterDecimalOption(s) + } +} + +func (s *MasterDecimalOptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitMasterDecimalOption(s) + } +} + +func (p *MySqlParser) MasterOption() (localctx IMasterOptionContext) { + localctx = NewMasterOptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 348, MySqlParserRULE_masterOption) + var _la int + + p.SetState(4534) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserMASTER_BIND, MySqlParserMASTER_HOST, MySqlParserMASTER_LOG_FILE, MySqlParserMASTER_PASSWORD, MySqlParserMASTER_SSL_CA, MySqlParserMASTER_SSL_CAPATH, MySqlParserMASTER_SSL_CERT, MySqlParserMASTER_SSL_CIPHER, MySqlParserMASTER_SSL_CRL, MySqlParserMASTER_SSL_CRLPATH, MySqlParserMASTER_SSL_KEY, MySqlParserMASTER_TLS_VERSION, MySqlParserMASTER_USER, MySqlParserRELAY_LOG_FILE: + localctx = NewMasterStringOptionContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4505) + p.StringMasterOption() + } + { + p.SetState(4506) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4507) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserMASTER_CONNECT_RETRY, MySqlParserMASTER_DELAY, MySqlParserMASTER_LOG_POS, MySqlParserMASTER_PORT, MySqlParserMASTER_RETRY_COUNT, MySqlParserRELAY_LOG_POS: + localctx = NewMasterDecimalOptionContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4509) + p.DecimalMasterOption() + } + { + p.SetState(4510) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4511) + p.DecimalLiteral() + } + + case MySqlParserMASTER_SSL_VERIFY_SERVER_CERT, MySqlParserMASTER_AUTO_POSITION, MySqlParserMASTER_SSL: + localctx = NewMasterBoolOptionContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4513) + p.BoolMasterOption() + } + { + p.SetState(4514) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4515) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*MasterBoolOptionContext).boolVal = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserZERO_DECIMAL || _la == MySqlParserONE_DECIMAL) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*MasterBoolOptionContext).boolVal = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case MySqlParserMASTER_HEARTBEAT_PERIOD: + localctx = NewMasterRealOptionContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4517) + p.Match(MySqlParserMASTER_HEARTBEAT_PERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4518) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4519) + p.Match(MySqlParserREAL_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserIGNORE_SERVER_IDS: + localctx = NewMasterUidListOptionContext(p, localctx) + p.EnterOuterAlt(localctx, 5) + { + p.SetState(4520) + p.Match(MySqlParserIGNORE_SERVER_IDS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4521) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4522) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4531) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-34354363873) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-2199023255553) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-5764611921080745985) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-8796126576641) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-32651097298436097) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-18014398517872129) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-137438953601) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-44473063500156929) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-129) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-12289) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&-1) != 0) || ((int64((_la-1128)) & ^0x3f) == 0 && ((int64(1)<<(_la-1128))&8627683329) != 0) { + { + p.SetState(4523) + p.Uid() + } + p.SetState(4528) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(4524) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4525) + p.Uid() + } + + p.SetState(4530) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + { + p.SetState(4533) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStringMasterOptionContext is an interface to support dynamic dispatch. +type IStringMasterOptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MASTER_BIND() antlr.TerminalNode + MASTER_HOST() antlr.TerminalNode + MASTER_USER() antlr.TerminalNode + MASTER_PASSWORD() antlr.TerminalNode + MASTER_LOG_FILE() antlr.TerminalNode + RELAY_LOG_FILE() antlr.TerminalNode + MASTER_SSL_CA() antlr.TerminalNode + MASTER_SSL_CAPATH() antlr.TerminalNode + MASTER_SSL_CERT() antlr.TerminalNode + MASTER_SSL_CRL() antlr.TerminalNode + MASTER_SSL_CRLPATH() antlr.TerminalNode + MASTER_SSL_KEY() antlr.TerminalNode + MASTER_SSL_CIPHER() antlr.TerminalNode + MASTER_TLS_VERSION() antlr.TerminalNode + + // IsStringMasterOptionContext differentiates from other interfaces. + IsStringMasterOptionContext() +} + +type StringMasterOptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStringMasterOptionContext() *StringMasterOptionContext { + var p = new(StringMasterOptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_stringMasterOption + return p +} + +func InitEmptyStringMasterOptionContext(p *StringMasterOptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_stringMasterOption +} + +func (*StringMasterOptionContext) IsStringMasterOptionContext() {} + +func NewStringMasterOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StringMasterOptionContext { + var p = new(StringMasterOptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_stringMasterOption + + return p +} + +func (s *StringMasterOptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *StringMasterOptionContext) MASTER_BIND() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER_BIND, 0) +} + +func (s *StringMasterOptionContext) MASTER_HOST() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER_HOST, 0) +} + +func (s *StringMasterOptionContext) MASTER_USER() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER_USER, 0) +} + +func (s *StringMasterOptionContext) MASTER_PASSWORD() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER_PASSWORD, 0) +} + +func (s *StringMasterOptionContext) MASTER_LOG_FILE() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER_LOG_FILE, 0) +} + +func (s *StringMasterOptionContext) RELAY_LOG_FILE() antlr.TerminalNode { + return s.GetToken(MySqlParserRELAY_LOG_FILE, 0) +} + +func (s *StringMasterOptionContext) MASTER_SSL_CA() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER_SSL_CA, 0) +} + +func (s *StringMasterOptionContext) MASTER_SSL_CAPATH() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER_SSL_CAPATH, 0) +} + +func (s *StringMasterOptionContext) MASTER_SSL_CERT() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER_SSL_CERT, 0) +} + +func (s *StringMasterOptionContext) MASTER_SSL_CRL() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER_SSL_CRL, 0) +} + +func (s *StringMasterOptionContext) MASTER_SSL_CRLPATH() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER_SSL_CRLPATH, 0) +} + +func (s *StringMasterOptionContext) MASTER_SSL_KEY() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER_SSL_KEY, 0) +} + +func (s *StringMasterOptionContext) MASTER_SSL_CIPHER() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER_SSL_CIPHER, 0) +} + +func (s *StringMasterOptionContext) MASTER_TLS_VERSION() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER_TLS_VERSION, 0) +} + +func (s *StringMasterOptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *StringMasterOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *StringMasterOptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterStringMasterOption(s) + } +} + +func (s *StringMasterOptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitStringMasterOption(s) + } +} + +func (p *MySqlParser) StringMasterOption() (localctx IStringMasterOptionContext) { + localctx = NewStringMasterOptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 350, MySqlParserRULE_stringMasterOption) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4536) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserMASTER_BIND || ((int64((_la-483)) & ^0x3f) == 0 && ((int64(1)<<(_la-483))&65419) != 0) || _la == MySqlParserRELAY_LOG_FILE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDecimalMasterOptionContext is an interface to support dynamic dispatch. +type IDecimalMasterOptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MASTER_PORT() antlr.TerminalNode + MASTER_CONNECT_RETRY() antlr.TerminalNode + MASTER_RETRY_COUNT() antlr.TerminalNode + MASTER_DELAY() antlr.TerminalNode + MASTER_LOG_POS() antlr.TerminalNode + RELAY_LOG_POS() antlr.TerminalNode + + // IsDecimalMasterOptionContext differentiates from other interfaces. + IsDecimalMasterOptionContext() +} + +type DecimalMasterOptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDecimalMasterOptionContext() *DecimalMasterOptionContext { + var p = new(DecimalMasterOptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_decimalMasterOption + return p +} + +func InitEmptyDecimalMasterOptionContext(p *DecimalMasterOptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_decimalMasterOption +} + +func (*DecimalMasterOptionContext) IsDecimalMasterOptionContext() {} + +func NewDecimalMasterOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DecimalMasterOptionContext { + var p = new(DecimalMasterOptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_decimalMasterOption + + return p +} + +func (s *DecimalMasterOptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *DecimalMasterOptionContext) MASTER_PORT() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER_PORT, 0) +} + +func (s *DecimalMasterOptionContext) MASTER_CONNECT_RETRY() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER_CONNECT_RETRY, 0) +} + +func (s *DecimalMasterOptionContext) MASTER_RETRY_COUNT() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER_RETRY_COUNT, 0) +} + +func (s *DecimalMasterOptionContext) MASTER_DELAY() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER_DELAY, 0) +} + +func (s *DecimalMasterOptionContext) MASTER_LOG_POS() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER_LOG_POS, 0) +} + +func (s *DecimalMasterOptionContext) RELAY_LOG_POS() antlr.TerminalNode { + return s.GetToken(MySqlParserRELAY_LOG_POS, 0) +} + +func (s *DecimalMasterOptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DecimalMasterOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DecimalMasterOptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterDecimalMasterOption(s) + } +} + +func (s *DecimalMasterOptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitDecimalMasterOption(s) + } +} + +func (p *MySqlParser) DecimalMasterOption() (localctx IDecimalMasterOptionContext) { + localctx = NewDecimalMasterOptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 352, MySqlParserRULE_decimalMasterOption) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4538) + _la = p.GetTokenStream().LA(1) + + if !(((int64((_la-480)) & ^0x3f) == 0 && ((int64(1)<<(_la-480))&419) != 0) || _la == MySqlParserRELAY_LOG_POS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBoolMasterOptionContext is an interface to support dynamic dispatch. +type IBoolMasterOptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MASTER_AUTO_POSITION() antlr.TerminalNode + MASTER_SSL() antlr.TerminalNode + MASTER_SSL_VERIFY_SERVER_CERT() antlr.TerminalNode + + // IsBoolMasterOptionContext differentiates from other interfaces. + IsBoolMasterOptionContext() +} + +type BoolMasterOptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBoolMasterOptionContext() *BoolMasterOptionContext { + var p = new(BoolMasterOptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_boolMasterOption + return p +} + +func InitEmptyBoolMasterOptionContext(p *BoolMasterOptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_boolMasterOption +} + +func (*BoolMasterOptionContext) IsBoolMasterOptionContext() {} + +func NewBoolMasterOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BoolMasterOptionContext { + var p = new(BoolMasterOptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_boolMasterOption + + return p +} + +func (s *BoolMasterOptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *BoolMasterOptionContext) MASTER_AUTO_POSITION() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER_AUTO_POSITION, 0) +} + +func (s *BoolMasterOptionContext) MASTER_SSL() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER_SSL, 0) +} + +func (s *BoolMasterOptionContext) MASTER_SSL_VERIFY_SERVER_CERT() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER_SSL_VERIFY_SERVER_CERT, 0) +} + +func (s *BoolMasterOptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *BoolMasterOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *BoolMasterOptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterBoolMasterOption(s) + } +} + +func (s *BoolMasterOptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitBoolMasterOption(s) + } +} + +func (p *MySqlParser) BoolMasterOption() (localctx IBoolMasterOptionContext) { + localctx = NewBoolMasterOptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 354, MySqlParserRULE_boolMasterOption) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4540) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserMASTER_SSL_VERIFY_SERVER_CERT || _la == MySqlParserMASTER_AUTO_POSITION || _la == MySqlParserMASTER_SSL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IChannelOptionContext is an interface to support dynamic dispatch. +type IChannelOptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FOR() antlr.TerminalNode + CHANNEL() antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + + // IsChannelOptionContext differentiates from other interfaces. + IsChannelOptionContext() +} + +type ChannelOptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyChannelOptionContext() *ChannelOptionContext { + var p = new(ChannelOptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_channelOption + return p +} + +func InitEmptyChannelOptionContext(p *ChannelOptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_channelOption +} + +func (*ChannelOptionContext) IsChannelOptionContext() {} + +func NewChannelOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ChannelOptionContext { + var p = new(ChannelOptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_channelOption + + return p +} + +func (s *ChannelOptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *ChannelOptionContext) FOR() antlr.TerminalNode { + return s.GetToken(MySqlParserFOR, 0) +} + +func (s *ChannelOptionContext) CHANNEL() antlr.TerminalNode { + return s.GetToken(MySqlParserCHANNEL, 0) +} + +func (s *ChannelOptionContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *ChannelOptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ChannelOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ChannelOptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterChannelOption(s) + } +} + +func (s *ChannelOptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitChannelOption(s) + } +} + +func (p *MySqlParser) ChannelOption() (localctx IChannelOptionContext) { + localctx = NewChannelOptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 356, MySqlParserRULE_channelOption) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4542) + p.Match(MySqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4543) + p.Match(MySqlParserCHANNEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4544) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReplicationFilterContext is an interface to support dynamic dispatch. +type IReplicationFilterContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsReplicationFilterContext differentiates from other interfaces. + IsReplicationFilterContext() +} + +type ReplicationFilterContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReplicationFilterContext() *ReplicationFilterContext { + var p = new(ReplicationFilterContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_replicationFilter + return p +} + +func InitEmptyReplicationFilterContext(p *ReplicationFilterContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_replicationFilter +} + +func (*ReplicationFilterContext) IsReplicationFilterContext() {} + +func NewReplicationFilterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReplicationFilterContext { + var p = new(ReplicationFilterContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_replicationFilter + + return p +} + +func (s *ReplicationFilterContext) GetParser() antlr.Parser { return s.parser } + +func (s *ReplicationFilterContext) CopyAll(ctx *ReplicationFilterContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *ReplicationFilterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ReplicationFilterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type WildIgnoreTableReplicationContext struct { + ReplicationFilterContext +} + +func NewWildIgnoreTableReplicationContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *WildIgnoreTableReplicationContext { + var p = new(WildIgnoreTableReplicationContext) + + InitEmptyReplicationFilterContext(&p.ReplicationFilterContext) + p.parser = parser + p.CopyAll(ctx.(*ReplicationFilterContext)) + + return p +} + +func (s *WildIgnoreTableReplicationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *WildIgnoreTableReplicationContext) REPLICATE_WILD_IGNORE_TABLE() antlr.TerminalNode { + return s.GetToken(MySqlParserREPLICATE_WILD_IGNORE_TABLE, 0) +} + +func (s *WildIgnoreTableReplicationContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *WildIgnoreTableReplicationContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *WildIgnoreTableReplicationContext) SimpleStrings() ISimpleStringsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimpleStringsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISimpleStringsContext) +} + +func (s *WildIgnoreTableReplicationContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *WildIgnoreTableReplicationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterWildIgnoreTableReplication(s) + } +} + +func (s *WildIgnoreTableReplicationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitWildIgnoreTableReplication(s) + } +} + +type DoTableReplicationContext struct { + ReplicationFilterContext +} + +func NewDoTableReplicationContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DoTableReplicationContext { + var p = new(DoTableReplicationContext) + + InitEmptyReplicationFilterContext(&p.ReplicationFilterContext) + p.parser = parser + p.CopyAll(ctx.(*ReplicationFilterContext)) + + return p +} + +func (s *DoTableReplicationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DoTableReplicationContext) REPLICATE_DO_TABLE() antlr.TerminalNode { + return s.GetToken(MySqlParserREPLICATE_DO_TABLE, 0) +} + +func (s *DoTableReplicationContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *DoTableReplicationContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *DoTableReplicationContext) Tables() ITablesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablesContext) +} + +func (s *DoTableReplicationContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *DoTableReplicationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterDoTableReplication(s) + } +} + +func (s *DoTableReplicationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitDoTableReplication(s) + } +} + +type IgnoreTableReplicationContext struct { + ReplicationFilterContext +} + +func NewIgnoreTableReplicationContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IgnoreTableReplicationContext { + var p = new(IgnoreTableReplicationContext) + + InitEmptyReplicationFilterContext(&p.ReplicationFilterContext) + p.parser = parser + p.CopyAll(ctx.(*ReplicationFilterContext)) + + return p +} + +func (s *IgnoreTableReplicationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IgnoreTableReplicationContext) REPLICATE_IGNORE_TABLE() antlr.TerminalNode { + return s.GetToken(MySqlParserREPLICATE_IGNORE_TABLE, 0) +} + +func (s *IgnoreTableReplicationContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *IgnoreTableReplicationContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *IgnoreTableReplicationContext) Tables() ITablesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablesContext) +} + +func (s *IgnoreTableReplicationContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *IgnoreTableReplicationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterIgnoreTableReplication(s) + } +} + +func (s *IgnoreTableReplicationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitIgnoreTableReplication(s) + } +} + +type RewriteDbReplicationContext struct { + ReplicationFilterContext +} + +func NewRewriteDbReplicationContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RewriteDbReplicationContext { + var p = new(RewriteDbReplicationContext) + + InitEmptyReplicationFilterContext(&p.ReplicationFilterContext) + p.parser = parser + p.CopyAll(ctx.(*ReplicationFilterContext)) + + return p +} + +func (s *RewriteDbReplicationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RewriteDbReplicationContext) REPLICATE_REWRITE_DB() antlr.TerminalNode { + return s.GetToken(MySqlParserREPLICATE_REWRITE_DB, 0) +} + +func (s *RewriteDbReplicationContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *RewriteDbReplicationContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *RewriteDbReplicationContext) AllTablePair() []ITablePairContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITablePairContext); ok { + len++ + } + } + + tst := make([]ITablePairContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITablePairContext); ok { + tst[i] = t.(ITablePairContext) + i++ + } + } + + return tst +} + +func (s *RewriteDbReplicationContext) TablePair(i int) ITablePairContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablePairContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITablePairContext) +} + +func (s *RewriteDbReplicationContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *RewriteDbReplicationContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *RewriteDbReplicationContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *RewriteDbReplicationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterRewriteDbReplication(s) + } +} + +func (s *RewriteDbReplicationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitRewriteDbReplication(s) + } +} + +type DoDbReplicationContext struct { + ReplicationFilterContext +} + +func NewDoDbReplicationContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DoDbReplicationContext { + var p = new(DoDbReplicationContext) + + InitEmptyReplicationFilterContext(&p.ReplicationFilterContext) + p.parser = parser + p.CopyAll(ctx.(*ReplicationFilterContext)) + + return p +} + +func (s *DoDbReplicationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DoDbReplicationContext) REPLICATE_DO_DB() antlr.TerminalNode { + return s.GetToken(MySqlParserREPLICATE_DO_DB, 0) +} + +func (s *DoDbReplicationContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *DoDbReplicationContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *DoDbReplicationContext) UidList() IUidListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidListContext) +} + +func (s *DoDbReplicationContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *DoDbReplicationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterDoDbReplication(s) + } +} + +func (s *DoDbReplicationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitDoDbReplication(s) + } +} + +type IgnoreDbReplicationContext struct { + ReplicationFilterContext +} + +func NewIgnoreDbReplicationContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IgnoreDbReplicationContext { + var p = new(IgnoreDbReplicationContext) + + InitEmptyReplicationFilterContext(&p.ReplicationFilterContext) + p.parser = parser + p.CopyAll(ctx.(*ReplicationFilterContext)) + + return p +} + +func (s *IgnoreDbReplicationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IgnoreDbReplicationContext) REPLICATE_IGNORE_DB() antlr.TerminalNode { + return s.GetToken(MySqlParserREPLICATE_IGNORE_DB, 0) +} + +func (s *IgnoreDbReplicationContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *IgnoreDbReplicationContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *IgnoreDbReplicationContext) UidList() IUidListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidListContext) +} + +func (s *IgnoreDbReplicationContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *IgnoreDbReplicationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterIgnoreDbReplication(s) + } +} + +func (s *IgnoreDbReplicationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitIgnoreDbReplication(s) + } +} + +type WildDoTableReplicationContext struct { + ReplicationFilterContext +} + +func NewWildDoTableReplicationContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *WildDoTableReplicationContext { + var p = new(WildDoTableReplicationContext) + + InitEmptyReplicationFilterContext(&p.ReplicationFilterContext) + p.parser = parser + p.CopyAll(ctx.(*ReplicationFilterContext)) + + return p +} + +func (s *WildDoTableReplicationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *WildDoTableReplicationContext) REPLICATE_WILD_DO_TABLE() antlr.TerminalNode { + return s.GetToken(MySqlParserREPLICATE_WILD_DO_TABLE, 0) +} + +func (s *WildDoTableReplicationContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *WildDoTableReplicationContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *WildDoTableReplicationContext) SimpleStrings() ISimpleStringsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimpleStringsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISimpleStringsContext) +} + +func (s *WildDoTableReplicationContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *WildDoTableReplicationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterWildDoTableReplication(s) + } +} + +func (s *WildDoTableReplicationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitWildDoTableReplication(s) + } +} + +func (p *MySqlParser) ReplicationFilter() (localctx IReplicationFilterContext) { + localctx = NewReplicationFilterContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 358, MySqlParserRULE_replicationFilter) + var _la int + + p.SetState(4595) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserREPLICATE_DO_DB: + localctx = NewDoDbReplicationContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4546) + p.Match(MySqlParserREPLICATE_DO_DB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4547) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4548) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4549) + p.UidList() + } + { + p.SetState(4550) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserREPLICATE_IGNORE_DB: + localctx = NewIgnoreDbReplicationContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4552) + p.Match(MySqlParserREPLICATE_IGNORE_DB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4553) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4554) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4555) + p.UidList() + } + { + p.SetState(4556) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserREPLICATE_DO_TABLE: + localctx = NewDoTableReplicationContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4558) + p.Match(MySqlParserREPLICATE_DO_TABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4559) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4560) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4561) + p.Tables() + } + { + p.SetState(4562) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserREPLICATE_IGNORE_TABLE: + localctx = NewIgnoreTableReplicationContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4564) + p.Match(MySqlParserREPLICATE_IGNORE_TABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4565) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4566) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4567) + p.Tables() + } + { + p.SetState(4568) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserREPLICATE_WILD_DO_TABLE: + localctx = NewWildDoTableReplicationContext(p, localctx) + p.EnterOuterAlt(localctx, 5) + { + p.SetState(4570) + p.Match(MySqlParserREPLICATE_WILD_DO_TABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4571) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4572) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4573) + p.SimpleStrings() + } + { + p.SetState(4574) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserREPLICATE_WILD_IGNORE_TABLE: + localctx = NewWildIgnoreTableReplicationContext(p, localctx) + p.EnterOuterAlt(localctx, 6) + { + p.SetState(4576) + p.Match(MySqlParserREPLICATE_WILD_IGNORE_TABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4577) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4578) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4579) + p.SimpleStrings() + } + { + p.SetState(4580) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserREPLICATE_REWRITE_DB: + localctx = NewRewriteDbReplicationContext(p, localctx) + p.EnterOuterAlt(localctx, 7) + { + p.SetState(4582) + p.Match(MySqlParserREPLICATE_REWRITE_DB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4583) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4584) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4585) + p.TablePair() + } + p.SetState(4590) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(4586) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4587) + p.TablePair() + } + + p.SetState(4592) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(4593) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITablePairContext is an interface to support dynamic dispatch. +type ITablePairContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetFirstTable returns the firstTable rule contexts. + GetFirstTable() ITableNameContext + + // GetSecondTable returns the secondTable rule contexts. + GetSecondTable() ITableNameContext + + // SetFirstTable sets the firstTable rule contexts. + SetFirstTable(ITableNameContext) + + // SetSecondTable sets the secondTable rule contexts. + SetSecondTable(ITableNameContext) + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + COMMA() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + AllTableName() []ITableNameContext + TableName(i int) ITableNameContext + + // IsTablePairContext differentiates from other interfaces. + IsTablePairContext() +} + +type TablePairContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + firstTable ITableNameContext + secondTable ITableNameContext +} + +func NewEmptyTablePairContext() *TablePairContext { + var p = new(TablePairContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_tablePair + return p +} + +func InitEmptyTablePairContext(p *TablePairContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_tablePair +} + +func (*TablePairContext) IsTablePairContext() {} + +func NewTablePairContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TablePairContext { + var p = new(TablePairContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_tablePair + + return p +} + +func (s *TablePairContext) GetParser() antlr.Parser { return s.parser } + +func (s *TablePairContext) GetFirstTable() ITableNameContext { return s.firstTable } + +func (s *TablePairContext) GetSecondTable() ITableNameContext { return s.secondTable } + +func (s *TablePairContext) SetFirstTable(v ITableNameContext) { s.firstTable = v } + +func (s *TablePairContext) SetSecondTable(v ITableNameContext) { s.secondTable = v } + +func (s *TablePairContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *TablePairContext) COMMA() antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, 0) +} + +func (s *TablePairContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *TablePairContext) AllTableName() []ITableNameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITableNameContext); ok { + len++ + } + } + + tst := make([]ITableNameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITableNameContext); ok { + tst[i] = t.(ITableNameContext) + i++ + } + } + + return tst +} + +func (s *TablePairContext) TableName(i int) ITableNameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableNameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITableNameContext) +} + +func (s *TablePairContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TablePairContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TablePairContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTablePair(s) + } +} + +func (s *TablePairContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTablePair(s) + } +} + +func (p *MySqlParser) TablePair() (localctx ITablePairContext) { + localctx = NewTablePairContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 360, MySqlParserRULE_tablePair) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4597) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4598) + + var _x = p.TableName() + + localctx.(*TablePairContext).firstTable = _x + } + { + p.SetState(4599) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4600) + + var _x = p.TableName() + + localctx.(*TablePairContext).secondTable = _x + } + { + p.SetState(4601) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IThreadTypeContext is an interface to support dynamic dispatch. +type IThreadTypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IO_THREAD() antlr.TerminalNode + SQL_THREAD() antlr.TerminalNode + + // IsThreadTypeContext differentiates from other interfaces. + IsThreadTypeContext() +} + +type ThreadTypeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyThreadTypeContext() *ThreadTypeContext { + var p = new(ThreadTypeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_threadType + return p +} + +func InitEmptyThreadTypeContext(p *ThreadTypeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_threadType +} + +func (*ThreadTypeContext) IsThreadTypeContext() {} + +func NewThreadTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ThreadTypeContext { + var p = new(ThreadTypeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_threadType + + return p +} + +func (s *ThreadTypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *ThreadTypeContext) IO_THREAD() antlr.TerminalNode { + return s.GetToken(MySqlParserIO_THREAD, 0) +} + +func (s *ThreadTypeContext) SQL_THREAD() antlr.TerminalNode { + return s.GetToken(MySqlParserSQL_THREAD, 0) +} + +func (s *ThreadTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ThreadTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ThreadTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterThreadType(s) + } +} + +func (s *ThreadTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitThreadType(s) + } +} + +func (p *MySqlParser) ThreadType() (localctx IThreadTypeContext) { + localctx = NewThreadTypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 362, MySqlParserRULE_threadType) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4603) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserIO_THREAD || _la == MySqlParserSQL_THREAD) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUntilOptionContext is an interface to support dynamic dispatch. +type IUntilOptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsUntilOptionContext differentiates from other interfaces. + IsUntilOptionContext() +} + +type UntilOptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUntilOptionContext() *UntilOptionContext { + var p = new(UntilOptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_untilOption + return p +} + +func InitEmptyUntilOptionContext(p *UntilOptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_untilOption +} + +func (*UntilOptionContext) IsUntilOptionContext() {} + +func NewUntilOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UntilOptionContext { + var p = new(UntilOptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_untilOption + + return p +} + +func (s *UntilOptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *UntilOptionContext) CopyAll(ctx *UntilOptionContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *UntilOptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UntilOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type GtidsUntilOptionContext struct { + UntilOptionContext + gtids antlr.Token +} + +func NewGtidsUntilOptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *GtidsUntilOptionContext { + var p = new(GtidsUntilOptionContext) + + InitEmptyUntilOptionContext(&p.UntilOptionContext) + p.parser = parser + p.CopyAll(ctx.(*UntilOptionContext)) + + return p +} + +func (s *GtidsUntilOptionContext) GetGtids() antlr.Token { return s.gtids } + +func (s *GtidsUntilOptionContext) SetGtids(v antlr.Token) { s.gtids = v } + +func (s *GtidsUntilOptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *GtidsUntilOptionContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *GtidsUntilOptionContext) GtuidSet() IGtuidSetContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGtuidSetContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGtuidSetContext) +} + +func (s *GtidsUntilOptionContext) SQL_BEFORE_GTIDS() antlr.TerminalNode { + return s.GetToken(MySqlParserSQL_BEFORE_GTIDS, 0) +} + +func (s *GtidsUntilOptionContext) SQL_AFTER_GTIDS() antlr.TerminalNode { + return s.GetToken(MySqlParserSQL_AFTER_GTIDS, 0) +} + +func (s *GtidsUntilOptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterGtidsUntilOption(s) + } +} + +func (s *GtidsUntilOptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitGtidsUntilOption(s) + } +} + +type SqlGapsUntilOptionContext struct { + UntilOptionContext +} + +func NewSqlGapsUntilOptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SqlGapsUntilOptionContext { + var p = new(SqlGapsUntilOptionContext) + + InitEmptyUntilOptionContext(&p.UntilOptionContext) + p.parser = parser + p.CopyAll(ctx.(*UntilOptionContext)) + + return p +} + +func (s *SqlGapsUntilOptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SqlGapsUntilOptionContext) SQL_AFTER_MTS_GAPS() antlr.TerminalNode { + return s.GetToken(MySqlParserSQL_AFTER_MTS_GAPS, 0) +} + +func (s *SqlGapsUntilOptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSqlGapsUntilOption(s) + } +} + +func (s *SqlGapsUntilOptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSqlGapsUntilOption(s) + } +} + +type MasterLogUntilOptionContext struct { + UntilOptionContext +} + +func NewMasterLogUntilOptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MasterLogUntilOptionContext { + var p = new(MasterLogUntilOptionContext) + + InitEmptyUntilOptionContext(&p.UntilOptionContext) + p.parser = parser + p.CopyAll(ctx.(*UntilOptionContext)) + + return p +} + +func (s *MasterLogUntilOptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MasterLogUntilOptionContext) MASTER_LOG_FILE() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER_LOG_FILE, 0) +} + +func (s *MasterLogUntilOptionContext) AllEQUAL_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(MySqlParserEQUAL_SYMBOL) +} + +func (s *MasterLogUntilOptionContext) EQUAL_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, i) +} + +func (s *MasterLogUntilOptionContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *MasterLogUntilOptionContext) COMMA() antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, 0) +} + +func (s *MasterLogUntilOptionContext) MASTER_LOG_POS() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER_LOG_POS, 0) +} + +func (s *MasterLogUntilOptionContext) DecimalLiteral() IDecimalLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *MasterLogUntilOptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterMasterLogUntilOption(s) + } +} + +func (s *MasterLogUntilOptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitMasterLogUntilOption(s) + } +} + +type RelayLogUntilOptionContext struct { + UntilOptionContext +} + +func NewRelayLogUntilOptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RelayLogUntilOptionContext { + var p = new(RelayLogUntilOptionContext) + + InitEmptyUntilOptionContext(&p.UntilOptionContext) + p.parser = parser + p.CopyAll(ctx.(*UntilOptionContext)) + + return p +} + +func (s *RelayLogUntilOptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RelayLogUntilOptionContext) RELAY_LOG_FILE() antlr.TerminalNode { + return s.GetToken(MySqlParserRELAY_LOG_FILE, 0) +} + +func (s *RelayLogUntilOptionContext) AllEQUAL_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(MySqlParserEQUAL_SYMBOL) +} + +func (s *RelayLogUntilOptionContext) EQUAL_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, i) +} + +func (s *RelayLogUntilOptionContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *RelayLogUntilOptionContext) COMMA() antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, 0) +} + +func (s *RelayLogUntilOptionContext) RELAY_LOG_POS() antlr.TerminalNode { + return s.GetToken(MySqlParserRELAY_LOG_POS, 0) +} + +func (s *RelayLogUntilOptionContext) DecimalLiteral() IDecimalLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *RelayLogUntilOptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterRelayLogUntilOption(s) + } +} + +func (s *RelayLogUntilOptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitRelayLogUntilOption(s) + } +} + +func (p *MySqlParser) UntilOption() (localctx IUntilOptionContext) { + localctx = NewUntilOptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 364, MySqlParserRULE_untilOption) + var _la int + + p.SetState(4623) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserSQL_AFTER_GTIDS, MySqlParserSQL_BEFORE_GTIDS: + localctx = NewGtidsUntilOptionContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4605) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*GtidsUntilOptionContext).gtids = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserSQL_AFTER_GTIDS || _la == MySqlParserSQL_BEFORE_GTIDS) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*GtidsUntilOptionContext).gtids = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(4606) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4607) + p.GtuidSet() + } + + case MySqlParserMASTER_LOG_FILE: + localctx = NewMasterLogUntilOptionContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4608) + p.Match(MySqlParserMASTER_LOG_FILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4609) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4610) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4611) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4612) + p.Match(MySqlParserMASTER_LOG_POS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4613) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4614) + p.DecimalLiteral() + } + + case MySqlParserRELAY_LOG_FILE: + localctx = NewRelayLogUntilOptionContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4615) + p.Match(MySqlParserRELAY_LOG_FILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4616) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4617) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4618) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4619) + p.Match(MySqlParserRELAY_LOG_POS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4620) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4621) + p.DecimalLiteral() + } + + case MySqlParserSQL_AFTER_MTS_GAPS: + localctx = NewSqlGapsUntilOptionContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4622) + p.Match(MySqlParserSQL_AFTER_MTS_GAPS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IConnectionOptionContext is an interface to support dynamic dispatch. +type IConnectionOptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsConnectionOptionContext differentiates from other interfaces. + IsConnectionOptionContext() +} + +type ConnectionOptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConnectionOptionContext() *ConnectionOptionContext { + var p = new(ConnectionOptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_connectionOption + return p +} + +func InitEmptyConnectionOptionContext(p *ConnectionOptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_connectionOption +} + +func (*ConnectionOptionContext) IsConnectionOptionContext() {} + +func NewConnectionOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConnectionOptionContext { + var p = new(ConnectionOptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_connectionOption + + return p +} + +func (s *ConnectionOptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *ConnectionOptionContext) CopyAll(ctx *ConnectionOptionContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *ConnectionOptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ConnectionOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type PluginDirConnectionOptionContext struct { + ConnectionOptionContext + conOptPluginDir antlr.Token +} + +func NewPluginDirConnectionOptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PluginDirConnectionOptionContext { + var p = new(PluginDirConnectionOptionContext) + + InitEmptyConnectionOptionContext(&p.ConnectionOptionContext) + p.parser = parser + p.CopyAll(ctx.(*ConnectionOptionContext)) + + return p +} + +func (s *PluginDirConnectionOptionContext) GetConOptPluginDir() antlr.Token { return s.conOptPluginDir } + +func (s *PluginDirConnectionOptionContext) SetConOptPluginDir(v antlr.Token) { s.conOptPluginDir = v } + +func (s *PluginDirConnectionOptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PluginDirConnectionOptionContext) PLUGIN_DIR() antlr.TerminalNode { + return s.GetToken(MySqlParserPLUGIN_DIR, 0) +} + +func (s *PluginDirConnectionOptionContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *PluginDirConnectionOptionContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *PluginDirConnectionOptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterPluginDirConnectionOption(s) + } +} + +func (s *PluginDirConnectionOptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitPluginDirConnectionOption(s) + } +} + +type UserConnectionOptionContext struct { + ConnectionOptionContext + conOptUser antlr.Token +} + +func NewUserConnectionOptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *UserConnectionOptionContext { + var p = new(UserConnectionOptionContext) + + InitEmptyConnectionOptionContext(&p.ConnectionOptionContext) + p.parser = parser + p.CopyAll(ctx.(*ConnectionOptionContext)) + + return p +} + +func (s *UserConnectionOptionContext) GetConOptUser() antlr.Token { return s.conOptUser } + +func (s *UserConnectionOptionContext) SetConOptUser(v antlr.Token) { s.conOptUser = v } + +func (s *UserConnectionOptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UserConnectionOptionContext) USER() antlr.TerminalNode { + return s.GetToken(MySqlParserUSER, 0) +} + +func (s *UserConnectionOptionContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *UserConnectionOptionContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *UserConnectionOptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterUserConnectionOption(s) + } +} + +func (s *UserConnectionOptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitUserConnectionOption(s) + } +} + +type DefaultAuthConnectionOptionContext struct { + ConnectionOptionContext + conOptDefAuth antlr.Token +} + +func NewDefaultAuthConnectionOptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DefaultAuthConnectionOptionContext { + var p = new(DefaultAuthConnectionOptionContext) + + InitEmptyConnectionOptionContext(&p.ConnectionOptionContext) + p.parser = parser + p.CopyAll(ctx.(*ConnectionOptionContext)) + + return p +} + +func (s *DefaultAuthConnectionOptionContext) GetConOptDefAuth() antlr.Token { return s.conOptDefAuth } + +func (s *DefaultAuthConnectionOptionContext) SetConOptDefAuth(v antlr.Token) { s.conOptDefAuth = v } + +func (s *DefaultAuthConnectionOptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DefaultAuthConnectionOptionContext) DEFAULT_AUTH() antlr.TerminalNode { + return s.GetToken(MySqlParserDEFAULT_AUTH, 0) +} + +func (s *DefaultAuthConnectionOptionContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *DefaultAuthConnectionOptionContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *DefaultAuthConnectionOptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterDefaultAuthConnectionOption(s) + } +} + +func (s *DefaultAuthConnectionOptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitDefaultAuthConnectionOption(s) + } +} + +type PasswordConnectionOptionContext struct { + ConnectionOptionContext + conOptPassword antlr.Token +} + +func NewPasswordConnectionOptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PasswordConnectionOptionContext { + var p = new(PasswordConnectionOptionContext) + + InitEmptyConnectionOptionContext(&p.ConnectionOptionContext) + p.parser = parser + p.CopyAll(ctx.(*ConnectionOptionContext)) + + return p +} + +func (s *PasswordConnectionOptionContext) GetConOptPassword() antlr.Token { return s.conOptPassword } + +func (s *PasswordConnectionOptionContext) SetConOptPassword(v antlr.Token) { s.conOptPassword = v } + +func (s *PasswordConnectionOptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PasswordConnectionOptionContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(MySqlParserPASSWORD, 0) +} + +func (s *PasswordConnectionOptionContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *PasswordConnectionOptionContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *PasswordConnectionOptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterPasswordConnectionOption(s) + } +} + +func (s *PasswordConnectionOptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitPasswordConnectionOption(s) + } +} + +func (p *MySqlParser) ConnectionOption() (localctx IConnectionOptionContext) { + localctx = NewConnectionOptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 366, MySqlParserRULE_connectionOption) + p.SetState(4637) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserUSER: + localctx = NewUserConnectionOptionContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4625) + p.Match(MySqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4626) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4627) + + var _m = p.Match(MySqlParserSTRING_LITERAL) + + localctx.(*UserConnectionOptionContext).conOptUser = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserPASSWORD: + localctx = NewPasswordConnectionOptionContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4628) + p.Match(MySqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4629) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4630) + + var _m = p.Match(MySqlParserSTRING_LITERAL) + + localctx.(*PasswordConnectionOptionContext).conOptPassword = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserDEFAULT_AUTH: + localctx = NewDefaultAuthConnectionOptionContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4631) + p.Match(MySqlParserDEFAULT_AUTH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4632) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4633) + + var _m = p.Match(MySqlParserSTRING_LITERAL) + + localctx.(*DefaultAuthConnectionOptionContext).conOptDefAuth = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserPLUGIN_DIR: + localctx = NewPluginDirConnectionOptionContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4634) + p.Match(MySqlParserPLUGIN_DIR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4635) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4636) + + var _m = p.Match(MySqlParserSTRING_LITERAL) + + localctx.(*PluginDirConnectionOptionContext).conOptPluginDir = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGtuidSetContext is an interface to support dynamic dispatch. +type IGtuidSetContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllUuidSet() []IUuidSetContext + UuidSet(i int) IUuidSetContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + + // IsGtuidSetContext differentiates from other interfaces. + IsGtuidSetContext() +} + +type GtuidSetContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGtuidSetContext() *GtuidSetContext { + var p = new(GtuidSetContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_gtuidSet + return p +} + +func InitEmptyGtuidSetContext(p *GtuidSetContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_gtuidSet +} + +func (*GtuidSetContext) IsGtuidSetContext() {} + +func NewGtuidSetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GtuidSetContext { + var p = new(GtuidSetContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_gtuidSet + + return p +} + +func (s *GtuidSetContext) GetParser() antlr.Parser { return s.parser } + +func (s *GtuidSetContext) AllUuidSet() []IUuidSetContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUuidSetContext); ok { + len++ + } + } + + tst := make([]IUuidSetContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUuidSetContext); ok { + tst[i] = t.(IUuidSetContext) + i++ + } + } + + return tst +} + +func (s *GtuidSetContext) UuidSet(i int) IUuidSetContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUuidSetContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUuidSetContext) +} + +func (s *GtuidSetContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *GtuidSetContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *GtuidSetContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *GtuidSetContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *GtuidSetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *GtuidSetContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterGtuidSet(s) + } +} + +func (s *GtuidSetContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitGtuidSet(s) + } +} + +func (p *MySqlParser) GtuidSet() (localctx IGtuidSetContext) { + localctx = NewGtuidSetContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 368, MySqlParserRULE_gtuidSet) + var _la int + + p.SetState(4648) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserZERO_DECIMAL, MySqlParserONE_DECIMAL, MySqlParserTWO_DECIMAL, MySqlParserDECIMAL_LITERAL, MySqlParserREAL_LITERAL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4639) + p.UuidSet() + } + p.SetState(4644) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(4640) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4641) + p.UuidSet() + } + + p.SetState(4646) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case MySqlParserSTRING_LITERAL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4647) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXaStartTransactionContext is an interface to support dynamic dispatch. +type IXaStartTransactionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetXaStart returns the xaStart token. + GetXaStart() antlr.Token + + // GetXaAction returns the xaAction token. + GetXaAction() antlr.Token + + // SetXaStart sets the xaStart token. + SetXaStart(antlr.Token) + + // SetXaAction sets the xaAction token. + SetXaAction(antlr.Token) + + // Getter signatures + XA() antlr.TerminalNode + Xid() IXidContext + START() antlr.TerminalNode + BEGIN() antlr.TerminalNode + JOIN() antlr.TerminalNode + RESUME() antlr.TerminalNode + + // IsXaStartTransactionContext differentiates from other interfaces. + IsXaStartTransactionContext() +} + +type XaStartTransactionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + xaStart antlr.Token + xaAction antlr.Token +} + +func NewEmptyXaStartTransactionContext() *XaStartTransactionContext { + var p = new(XaStartTransactionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_xaStartTransaction + return p +} + +func InitEmptyXaStartTransactionContext(p *XaStartTransactionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_xaStartTransaction +} + +func (*XaStartTransactionContext) IsXaStartTransactionContext() {} + +func NewXaStartTransactionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *XaStartTransactionContext { + var p = new(XaStartTransactionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_xaStartTransaction + + return p +} + +func (s *XaStartTransactionContext) GetParser() antlr.Parser { return s.parser } + +func (s *XaStartTransactionContext) GetXaStart() antlr.Token { return s.xaStart } + +func (s *XaStartTransactionContext) GetXaAction() antlr.Token { return s.xaAction } + +func (s *XaStartTransactionContext) SetXaStart(v antlr.Token) { s.xaStart = v } + +func (s *XaStartTransactionContext) SetXaAction(v antlr.Token) { s.xaAction = v } + +func (s *XaStartTransactionContext) XA() antlr.TerminalNode { + return s.GetToken(MySqlParserXA, 0) +} + +func (s *XaStartTransactionContext) Xid() IXidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXidContext) +} + +func (s *XaStartTransactionContext) START() antlr.TerminalNode { + return s.GetToken(MySqlParserSTART, 0) +} + +func (s *XaStartTransactionContext) BEGIN() antlr.TerminalNode { + return s.GetToken(MySqlParserBEGIN, 0) +} + +func (s *XaStartTransactionContext) JOIN() antlr.TerminalNode { + return s.GetToken(MySqlParserJOIN, 0) +} + +func (s *XaStartTransactionContext) RESUME() antlr.TerminalNode { + return s.GetToken(MySqlParserRESUME, 0) +} + +func (s *XaStartTransactionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *XaStartTransactionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *XaStartTransactionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterXaStartTransaction(s) + } +} + +func (s *XaStartTransactionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitXaStartTransaction(s) + } +} + +func (p *MySqlParser) XaStartTransaction() (localctx IXaStartTransactionContext) { + localctx = NewXaStartTransactionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 370, MySqlParserRULE_xaStartTransaction) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4650) + p.Match(MySqlParserXA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4651) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*XaStartTransactionContext).xaStart = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserBEGIN || _la == MySqlParserSTART) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*XaStartTransactionContext).xaStart = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(4652) + p.Xid() + } + p.SetState(4654) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserJOIN || _la == MySqlParserRESUME { + { + p.SetState(4653) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*XaStartTransactionContext).xaAction = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserJOIN || _la == MySqlParserRESUME) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*XaStartTransactionContext).xaAction = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXaEndTransactionContext is an interface to support dynamic dispatch. +type IXaEndTransactionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + XA() antlr.TerminalNode + END() antlr.TerminalNode + Xid() IXidContext + SUSPEND() antlr.TerminalNode + FOR() antlr.TerminalNode + MIGRATE() antlr.TerminalNode + + // IsXaEndTransactionContext differentiates from other interfaces. + IsXaEndTransactionContext() +} + +type XaEndTransactionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXaEndTransactionContext() *XaEndTransactionContext { + var p = new(XaEndTransactionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_xaEndTransaction + return p +} + +func InitEmptyXaEndTransactionContext(p *XaEndTransactionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_xaEndTransaction +} + +func (*XaEndTransactionContext) IsXaEndTransactionContext() {} + +func NewXaEndTransactionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *XaEndTransactionContext { + var p = new(XaEndTransactionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_xaEndTransaction + + return p +} + +func (s *XaEndTransactionContext) GetParser() antlr.Parser { return s.parser } + +func (s *XaEndTransactionContext) XA() antlr.TerminalNode { + return s.GetToken(MySqlParserXA, 0) +} + +func (s *XaEndTransactionContext) END() antlr.TerminalNode { + return s.GetToken(MySqlParserEND, 0) +} + +func (s *XaEndTransactionContext) Xid() IXidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXidContext) +} + +func (s *XaEndTransactionContext) SUSPEND() antlr.TerminalNode { + return s.GetToken(MySqlParserSUSPEND, 0) +} + +func (s *XaEndTransactionContext) FOR() antlr.TerminalNode { + return s.GetToken(MySqlParserFOR, 0) +} + +func (s *XaEndTransactionContext) MIGRATE() antlr.TerminalNode { + return s.GetToken(MySqlParserMIGRATE, 0) +} + +func (s *XaEndTransactionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *XaEndTransactionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *XaEndTransactionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterXaEndTransaction(s) + } +} + +func (s *XaEndTransactionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitXaEndTransaction(s) + } +} + +func (p *MySqlParser) XaEndTransaction() (localctx IXaEndTransactionContext) { + localctx = NewXaEndTransactionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 372, MySqlParserRULE_xaEndTransaction) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4656) + p.Match(MySqlParserXA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4657) + p.Match(MySqlParserEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4658) + p.Xid() + } + p.SetState(4664) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserSUSPEND { + { + p.SetState(4659) + p.Match(MySqlParserSUSPEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4662) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserFOR { + { + p.SetState(4660) + p.Match(MySqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4661) + p.Match(MySqlParserMIGRATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXaPrepareStatementContext is an interface to support dynamic dispatch. +type IXaPrepareStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + XA() antlr.TerminalNode + PREPARE() antlr.TerminalNode + Xid() IXidContext + + // IsXaPrepareStatementContext differentiates from other interfaces. + IsXaPrepareStatementContext() +} + +type XaPrepareStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXaPrepareStatementContext() *XaPrepareStatementContext { + var p = new(XaPrepareStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_xaPrepareStatement + return p +} + +func InitEmptyXaPrepareStatementContext(p *XaPrepareStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_xaPrepareStatement +} + +func (*XaPrepareStatementContext) IsXaPrepareStatementContext() {} + +func NewXaPrepareStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *XaPrepareStatementContext { + var p = new(XaPrepareStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_xaPrepareStatement + + return p +} + +func (s *XaPrepareStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *XaPrepareStatementContext) XA() antlr.TerminalNode { + return s.GetToken(MySqlParserXA, 0) +} + +func (s *XaPrepareStatementContext) PREPARE() antlr.TerminalNode { + return s.GetToken(MySqlParserPREPARE, 0) +} + +func (s *XaPrepareStatementContext) Xid() IXidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXidContext) +} + +func (s *XaPrepareStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *XaPrepareStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *XaPrepareStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterXaPrepareStatement(s) + } +} + +func (s *XaPrepareStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitXaPrepareStatement(s) + } +} + +func (p *MySqlParser) XaPrepareStatement() (localctx IXaPrepareStatementContext) { + localctx = NewXaPrepareStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 374, MySqlParserRULE_xaPrepareStatement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4666) + p.Match(MySqlParserXA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4667) + p.Match(MySqlParserPREPARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4668) + p.Xid() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXaCommitWorkContext is an interface to support dynamic dispatch. +type IXaCommitWorkContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + XA() antlr.TerminalNode + COMMIT() antlr.TerminalNode + Xid() IXidContext + ONE() antlr.TerminalNode + PHASE() antlr.TerminalNode + + // IsXaCommitWorkContext differentiates from other interfaces. + IsXaCommitWorkContext() +} + +type XaCommitWorkContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXaCommitWorkContext() *XaCommitWorkContext { + var p = new(XaCommitWorkContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_xaCommitWork + return p +} + +func InitEmptyXaCommitWorkContext(p *XaCommitWorkContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_xaCommitWork +} + +func (*XaCommitWorkContext) IsXaCommitWorkContext() {} + +func NewXaCommitWorkContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *XaCommitWorkContext { + var p = new(XaCommitWorkContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_xaCommitWork + + return p +} + +func (s *XaCommitWorkContext) GetParser() antlr.Parser { return s.parser } + +func (s *XaCommitWorkContext) XA() antlr.TerminalNode { + return s.GetToken(MySqlParserXA, 0) +} + +func (s *XaCommitWorkContext) COMMIT() antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMIT, 0) +} + +func (s *XaCommitWorkContext) Xid() IXidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXidContext) +} + +func (s *XaCommitWorkContext) ONE() antlr.TerminalNode { + return s.GetToken(MySqlParserONE, 0) +} + +func (s *XaCommitWorkContext) PHASE() antlr.TerminalNode { + return s.GetToken(MySqlParserPHASE, 0) +} + +func (s *XaCommitWorkContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *XaCommitWorkContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *XaCommitWorkContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterXaCommitWork(s) + } +} + +func (s *XaCommitWorkContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitXaCommitWork(s) + } +} + +func (p *MySqlParser) XaCommitWork() (localctx IXaCommitWorkContext) { + localctx = NewXaCommitWorkContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 376, MySqlParserRULE_xaCommitWork) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4670) + p.Match(MySqlParserXA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4671) + p.Match(MySqlParserCOMMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4672) + p.Xid() + } + p.SetState(4675) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserONE { + { + p.SetState(4673) + p.Match(MySqlParserONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4674) + p.Match(MySqlParserPHASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXaRollbackWorkContext is an interface to support dynamic dispatch. +type IXaRollbackWorkContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + XA() antlr.TerminalNode + ROLLBACK() antlr.TerminalNode + Xid() IXidContext + + // IsXaRollbackWorkContext differentiates from other interfaces. + IsXaRollbackWorkContext() +} + +type XaRollbackWorkContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXaRollbackWorkContext() *XaRollbackWorkContext { + var p = new(XaRollbackWorkContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_xaRollbackWork + return p +} + +func InitEmptyXaRollbackWorkContext(p *XaRollbackWorkContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_xaRollbackWork +} + +func (*XaRollbackWorkContext) IsXaRollbackWorkContext() {} + +func NewXaRollbackWorkContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *XaRollbackWorkContext { + var p = new(XaRollbackWorkContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_xaRollbackWork + + return p +} + +func (s *XaRollbackWorkContext) GetParser() antlr.Parser { return s.parser } + +func (s *XaRollbackWorkContext) XA() antlr.TerminalNode { + return s.GetToken(MySqlParserXA, 0) +} + +func (s *XaRollbackWorkContext) ROLLBACK() antlr.TerminalNode { + return s.GetToken(MySqlParserROLLBACK, 0) +} + +func (s *XaRollbackWorkContext) Xid() IXidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXidContext) +} + +func (s *XaRollbackWorkContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *XaRollbackWorkContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *XaRollbackWorkContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterXaRollbackWork(s) + } +} + +func (s *XaRollbackWorkContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitXaRollbackWork(s) + } +} + +func (p *MySqlParser) XaRollbackWork() (localctx IXaRollbackWorkContext) { + localctx = NewXaRollbackWorkContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 378, MySqlParserRULE_xaRollbackWork) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4677) + p.Match(MySqlParserXA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4678) + p.Match(MySqlParserROLLBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4679) + p.Xid() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXaRecoverWorkContext is an interface to support dynamic dispatch. +type IXaRecoverWorkContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + XA() antlr.TerminalNode + RECOVER() antlr.TerminalNode + CONVERT() antlr.TerminalNode + Xid() IXidContext + + // IsXaRecoverWorkContext differentiates from other interfaces. + IsXaRecoverWorkContext() +} + +type XaRecoverWorkContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXaRecoverWorkContext() *XaRecoverWorkContext { + var p = new(XaRecoverWorkContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_xaRecoverWork + return p +} + +func InitEmptyXaRecoverWorkContext(p *XaRecoverWorkContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_xaRecoverWork +} + +func (*XaRecoverWorkContext) IsXaRecoverWorkContext() {} + +func NewXaRecoverWorkContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *XaRecoverWorkContext { + var p = new(XaRecoverWorkContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_xaRecoverWork + + return p +} + +func (s *XaRecoverWorkContext) GetParser() antlr.Parser { return s.parser } + +func (s *XaRecoverWorkContext) XA() antlr.TerminalNode { + return s.GetToken(MySqlParserXA, 0) +} + +func (s *XaRecoverWorkContext) RECOVER() antlr.TerminalNode { + return s.GetToken(MySqlParserRECOVER, 0) +} + +func (s *XaRecoverWorkContext) CONVERT() antlr.TerminalNode { + return s.GetToken(MySqlParserCONVERT, 0) +} + +func (s *XaRecoverWorkContext) Xid() IXidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXidContext) +} + +func (s *XaRecoverWorkContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *XaRecoverWorkContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *XaRecoverWorkContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterXaRecoverWork(s) + } +} + +func (s *XaRecoverWorkContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitXaRecoverWork(s) + } +} + +func (p *MySqlParser) XaRecoverWork() (localctx IXaRecoverWorkContext) { + localctx = NewXaRecoverWorkContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 380, MySqlParserRULE_xaRecoverWork) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4681) + p.Match(MySqlParserXA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4682) + p.Match(MySqlParserRECOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4685) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserCONVERT { + { + p.SetState(4683) + p.Match(MySqlParserCONVERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4684) + p.Xid() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPrepareStatementContext is an interface to support dynamic dispatch. +type IPrepareStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetQuery returns the query token. + GetQuery() antlr.Token + + // GetVariable returns the variable token. + GetVariable() antlr.Token + + // SetQuery sets the query token. + SetQuery(antlr.Token) + + // SetVariable sets the variable token. + SetVariable(antlr.Token) + + // Getter signatures + PREPARE() antlr.TerminalNode + Uid() IUidContext + FROM() antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + LOCAL_ID() antlr.TerminalNode + + // IsPrepareStatementContext differentiates from other interfaces. + IsPrepareStatementContext() +} + +type PrepareStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + query antlr.Token + variable antlr.Token +} + +func NewEmptyPrepareStatementContext() *PrepareStatementContext { + var p = new(PrepareStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_prepareStatement + return p +} + +func InitEmptyPrepareStatementContext(p *PrepareStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_prepareStatement +} + +func (*PrepareStatementContext) IsPrepareStatementContext() {} + +func NewPrepareStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrepareStatementContext { + var p = new(PrepareStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_prepareStatement + + return p +} + +func (s *PrepareStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *PrepareStatementContext) GetQuery() antlr.Token { return s.query } + +func (s *PrepareStatementContext) GetVariable() antlr.Token { return s.variable } + +func (s *PrepareStatementContext) SetQuery(v antlr.Token) { s.query = v } + +func (s *PrepareStatementContext) SetVariable(v antlr.Token) { s.variable = v } + +func (s *PrepareStatementContext) PREPARE() antlr.TerminalNode { + return s.GetToken(MySqlParserPREPARE, 0) +} + +func (s *PrepareStatementContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *PrepareStatementContext) FROM() antlr.TerminalNode { + return s.GetToken(MySqlParserFROM, 0) +} + +func (s *PrepareStatementContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *PrepareStatementContext) LOCAL_ID() antlr.TerminalNode { + return s.GetToken(MySqlParserLOCAL_ID, 0) +} + +func (s *PrepareStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PrepareStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PrepareStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterPrepareStatement(s) + } +} + +func (s *PrepareStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitPrepareStatement(s) + } +} + +func (p *MySqlParser) PrepareStatement() (localctx IPrepareStatementContext) { + localctx = NewPrepareStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 382, MySqlParserRULE_prepareStatement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4687) + p.Match(MySqlParserPREPARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4688) + p.Uid() + } + { + p.SetState(4689) + p.Match(MySqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4692) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserSTRING_LITERAL: + { + p.SetState(4690) + + var _m = p.Match(MySqlParserSTRING_LITERAL) + + localctx.(*PrepareStatementContext).query = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserLOCAL_ID: + { + p.SetState(4691) + + var _m = p.Match(MySqlParserLOCAL_ID) + + localctx.(*PrepareStatementContext).variable = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExecuteStatementContext is an interface to support dynamic dispatch. +type IExecuteStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXECUTE() antlr.TerminalNode + Uid() IUidContext + USING() antlr.TerminalNode + UserVariables() IUserVariablesContext + + // IsExecuteStatementContext differentiates from other interfaces. + IsExecuteStatementContext() +} + +type ExecuteStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExecuteStatementContext() *ExecuteStatementContext { + var p = new(ExecuteStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_executeStatement + return p +} + +func InitEmptyExecuteStatementContext(p *ExecuteStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_executeStatement +} + +func (*ExecuteStatementContext) IsExecuteStatementContext() {} + +func NewExecuteStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExecuteStatementContext { + var p = new(ExecuteStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_executeStatement + + return p +} + +func (s *ExecuteStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *ExecuteStatementContext) EXECUTE() antlr.TerminalNode { + return s.GetToken(MySqlParserEXECUTE, 0) +} + +func (s *ExecuteStatementContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *ExecuteStatementContext) USING() antlr.TerminalNode { + return s.GetToken(MySqlParserUSING, 0) +} + +func (s *ExecuteStatementContext) UserVariables() IUserVariablesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserVariablesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUserVariablesContext) +} + +func (s *ExecuteStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ExecuteStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ExecuteStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterExecuteStatement(s) + } +} + +func (s *ExecuteStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitExecuteStatement(s) + } +} + +func (p *MySqlParser) ExecuteStatement() (localctx IExecuteStatementContext) { + localctx = NewExecuteStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 384, MySqlParserRULE_executeStatement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4694) + p.Match(MySqlParserEXECUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4695) + p.Uid() + } + p.SetState(4698) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserUSING { + { + p.SetState(4696) + p.Match(MySqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4697) + p.UserVariables() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDeallocatePrepareContext is an interface to support dynamic dispatch. +type IDeallocatePrepareContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetDropFormat returns the dropFormat token. + GetDropFormat() antlr.Token + + // SetDropFormat sets the dropFormat token. + SetDropFormat(antlr.Token) + + // Getter signatures + PREPARE() antlr.TerminalNode + Uid() IUidContext + DEALLOCATE() antlr.TerminalNode + DROP() antlr.TerminalNode + + // IsDeallocatePrepareContext differentiates from other interfaces. + IsDeallocatePrepareContext() +} + +type DeallocatePrepareContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + dropFormat antlr.Token +} + +func NewEmptyDeallocatePrepareContext() *DeallocatePrepareContext { + var p = new(DeallocatePrepareContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_deallocatePrepare + return p +} + +func InitEmptyDeallocatePrepareContext(p *DeallocatePrepareContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_deallocatePrepare +} + +func (*DeallocatePrepareContext) IsDeallocatePrepareContext() {} + +func NewDeallocatePrepareContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DeallocatePrepareContext { + var p = new(DeallocatePrepareContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_deallocatePrepare + + return p +} + +func (s *DeallocatePrepareContext) GetParser() antlr.Parser { return s.parser } + +func (s *DeallocatePrepareContext) GetDropFormat() antlr.Token { return s.dropFormat } + +func (s *DeallocatePrepareContext) SetDropFormat(v antlr.Token) { s.dropFormat = v } + +func (s *DeallocatePrepareContext) PREPARE() antlr.TerminalNode { + return s.GetToken(MySqlParserPREPARE, 0) +} + +func (s *DeallocatePrepareContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *DeallocatePrepareContext) DEALLOCATE() antlr.TerminalNode { + return s.GetToken(MySqlParserDEALLOCATE, 0) +} + +func (s *DeallocatePrepareContext) DROP() antlr.TerminalNode { + return s.GetToken(MySqlParserDROP, 0) +} + +func (s *DeallocatePrepareContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DeallocatePrepareContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DeallocatePrepareContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterDeallocatePrepare(s) + } +} + +func (s *DeallocatePrepareContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitDeallocatePrepare(s) + } +} + +func (p *MySqlParser) DeallocatePrepare() (localctx IDeallocatePrepareContext) { + localctx = NewDeallocatePrepareContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 386, MySqlParserRULE_deallocatePrepare) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4700) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*DeallocatePrepareContext).dropFormat = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserDROP || _la == MySqlParserDEALLOCATE) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*DeallocatePrepareContext).dropFormat = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(4701) + p.Match(MySqlParserPREPARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4702) + p.Uid() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRoutineBodyContext is an interface to support dynamic dispatch. +type IRoutineBodyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BlockStatement() IBlockStatementContext + SqlStatement() ISqlStatementContext + + // IsRoutineBodyContext differentiates from other interfaces. + IsRoutineBodyContext() +} + +type RoutineBodyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRoutineBodyContext() *RoutineBodyContext { + var p = new(RoutineBodyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_routineBody + return p +} + +func InitEmptyRoutineBodyContext(p *RoutineBodyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_routineBody +} + +func (*RoutineBodyContext) IsRoutineBodyContext() {} + +func NewRoutineBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RoutineBodyContext { + var p = new(RoutineBodyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_routineBody + + return p +} + +func (s *RoutineBodyContext) GetParser() antlr.Parser { return s.parser } + +func (s *RoutineBodyContext) BlockStatement() IBlockStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBlockStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBlockStatementContext) +} + +func (s *RoutineBodyContext) SqlStatement() ISqlStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISqlStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISqlStatementContext) +} + +func (s *RoutineBodyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RoutineBodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RoutineBodyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterRoutineBody(s) + } +} + +func (s *RoutineBodyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitRoutineBody(s) + } +} + +func (p *MySqlParser) RoutineBody() (localctx IRoutineBodyContext) { + localctx = NewRoutineBodyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 388, MySqlParserRULE_routineBody) + p.SetState(4706) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 682, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4704) + p.BlockStatement() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4705) + p.SqlStatement() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBlockStatementContext is an interface to support dynamic dispatch. +type IBlockStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BEGIN() antlr.TerminalNode + END() antlr.TerminalNode + AllUid() []IUidContext + Uid(i int) IUidContext + COLON_SYMB() antlr.TerminalNode + AllDeclareVariable() []IDeclareVariableContext + DeclareVariable(i int) IDeclareVariableContext + AllSEMI() []antlr.TerminalNode + SEMI(i int) antlr.TerminalNode + AllDeclareCondition() []IDeclareConditionContext + DeclareCondition(i int) IDeclareConditionContext + AllDeclareCursor() []IDeclareCursorContext + DeclareCursor(i int) IDeclareCursorContext + AllDeclareHandler() []IDeclareHandlerContext + DeclareHandler(i int) IDeclareHandlerContext + AllProcedureSqlStatement() []IProcedureSqlStatementContext + ProcedureSqlStatement(i int) IProcedureSqlStatementContext + + // IsBlockStatementContext differentiates from other interfaces. + IsBlockStatementContext() +} + +type BlockStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBlockStatementContext() *BlockStatementContext { + var p = new(BlockStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_blockStatement + return p +} + +func InitEmptyBlockStatementContext(p *BlockStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_blockStatement +} + +func (*BlockStatementContext) IsBlockStatementContext() {} + +func NewBlockStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BlockStatementContext { + var p = new(BlockStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_blockStatement + + return p +} + +func (s *BlockStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *BlockStatementContext) BEGIN() antlr.TerminalNode { + return s.GetToken(MySqlParserBEGIN, 0) +} + +func (s *BlockStatementContext) END() antlr.TerminalNode { + return s.GetToken(MySqlParserEND, 0) +} + +func (s *BlockStatementContext) AllUid() []IUidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUidContext); ok { + len++ + } + } + + tst := make([]IUidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUidContext); ok { + tst[i] = t.(IUidContext) + i++ + } + } + + return tst +} + +func (s *BlockStatementContext) Uid(i int) IUidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *BlockStatementContext) COLON_SYMB() antlr.TerminalNode { + return s.GetToken(MySqlParserCOLON_SYMB, 0) +} + +func (s *BlockStatementContext) AllDeclareVariable() []IDeclareVariableContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDeclareVariableContext); ok { + len++ + } + } + + tst := make([]IDeclareVariableContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDeclareVariableContext); ok { + tst[i] = t.(IDeclareVariableContext) + i++ + } + } + + return tst +} + +func (s *BlockStatementContext) DeclareVariable(i int) IDeclareVariableContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeclareVariableContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDeclareVariableContext) +} + +func (s *BlockStatementContext) AllSEMI() []antlr.TerminalNode { + return s.GetTokens(MySqlParserSEMI) +} + +func (s *BlockStatementContext) SEMI(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserSEMI, i) +} + +func (s *BlockStatementContext) AllDeclareCondition() []IDeclareConditionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDeclareConditionContext); ok { + len++ + } + } + + tst := make([]IDeclareConditionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDeclareConditionContext); ok { + tst[i] = t.(IDeclareConditionContext) + i++ + } + } + + return tst +} + +func (s *BlockStatementContext) DeclareCondition(i int) IDeclareConditionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeclareConditionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDeclareConditionContext) +} + +func (s *BlockStatementContext) AllDeclareCursor() []IDeclareCursorContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDeclareCursorContext); ok { + len++ + } + } + + tst := make([]IDeclareCursorContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDeclareCursorContext); ok { + tst[i] = t.(IDeclareCursorContext) + i++ + } + } + + return tst +} + +func (s *BlockStatementContext) DeclareCursor(i int) IDeclareCursorContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeclareCursorContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDeclareCursorContext) +} + +func (s *BlockStatementContext) AllDeclareHandler() []IDeclareHandlerContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDeclareHandlerContext); ok { + len++ + } + } + + tst := make([]IDeclareHandlerContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDeclareHandlerContext); ok { + tst[i] = t.(IDeclareHandlerContext) + i++ + } + } + + return tst +} + +func (s *BlockStatementContext) DeclareHandler(i int) IDeclareHandlerContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeclareHandlerContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDeclareHandlerContext) +} + +func (s *BlockStatementContext) AllProcedureSqlStatement() []IProcedureSqlStatementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IProcedureSqlStatementContext); ok { + len++ + } + } + + tst := make([]IProcedureSqlStatementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IProcedureSqlStatementContext); ok { + tst[i] = t.(IProcedureSqlStatementContext) + i++ + } + } + + return tst +} + +func (s *BlockStatementContext) ProcedureSqlStatement(i int) IProcedureSqlStatementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProcedureSqlStatementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IProcedureSqlStatementContext) +} + +func (s *BlockStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *BlockStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *BlockStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterBlockStatement(s) + } +} + +func (s *BlockStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitBlockStatement(s) + } +} + +func (p *MySqlParser) BlockStatement() (localctx IBlockStatementContext) { + localctx = NewBlockStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 390, MySqlParserRULE_blockStatement) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(4711) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 683, p.GetParserRuleContext()) == 1 { + { + p.SetState(4708) + p.Uid() + } + { + p.SetState(4709) + p.Match(MySqlParserCOLON_SYMB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4713) + p.Match(MySqlParserBEGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4719) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 684, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(4714) + p.DeclareVariable() + } + { + p.SetState(4715) + p.Match(MySqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4721) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 684, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(4727) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 685, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(4722) + p.DeclareCondition() + } + { + p.SetState(4723) + p.Match(MySqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4729) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 685, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(4735) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 686, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(4730) + p.DeclareCursor() + } + { + p.SetState(4731) + p.Match(MySqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4737) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 686, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(4743) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserDECLARE { + { + p.SetState(4738) + p.DeclareHandler() + } + { + p.SetState(4739) + p.Match(MySqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(4745) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(4749) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 688, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(4746) + p.ProcedureSqlStatement() + } + + } + p.SetState(4751) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 688, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + { + p.SetState(4752) + p.Match(MySqlParserEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4754) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 689, p.GetParserRuleContext()) == 1 { + { + p.SetState(4753) + p.Uid() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICaseStatementContext is an interface to support dynamic dispatch. +type ICaseStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllCASE() []antlr.TerminalNode + CASE(i int) antlr.TerminalNode + END() antlr.TerminalNode + Uid() IUidContext + Expression() IExpressionContext + AllCaseAlternative() []ICaseAlternativeContext + CaseAlternative(i int) ICaseAlternativeContext + ELSE() antlr.TerminalNode + AllProcedureSqlStatement() []IProcedureSqlStatementContext + ProcedureSqlStatement(i int) IProcedureSqlStatementContext + + // IsCaseStatementContext differentiates from other interfaces. + IsCaseStatementContext() +} + +type CaseStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCaseStatementContext() *CaseStatementContext { + var p = new(CaseStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_caseStatement + return p +} + +func InitEmptyCaseStatementContext(p *CaseStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_caseStatement +} + +func (*CaseStatementContext) IsCaseStatementContext() {} + +func NewCaseStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CaseStatementContext { + var p = new(CaseStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_caseStatement + + return p +} + +func (s *CaseStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *CaseStatementContext) AllCASE() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCASE) +} + +func (s *CaseStatementContext) CASE(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCASE, i) +} + +func (s *CaseStatementContext) END() antlr.TerminalNode { + return s.GetToken(MySqlParserEND, 0) +} + +func (s *CaseStatementContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *CaseStatementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *CaseStatementContext) AllCaseAlternative() []ICaseAlternativeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICaseAlternativeContext); ok { + len++ + } + } + + tst := make([]ICaseAlternativeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICaseAlternativeContext); ok { + tst[i] = t.(ICaseAlternativeContext) + i++ + } + } + + return tst +} + +func (s *CaseStatementContext) CaseAlternative(i int) ICaseAlternativeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICaseAlternativeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICaseAlternativeContext) +} + +func (s *CaseStatementContext) ELSE() antlr.TerminalNode { + return s.GetToken(MySqlParserELSE, 0) +} + +func (s *CaseStatementContext) AllProcedureSqlStatement() []IProcedureSqlStatementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IProcedureSqlStatementContext); ok { + len++ + } + } + + tst := make([]IProcedureSqlStatementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IProcedureSqlStatementContext); ok { + tst[i] = t.(IProcedureSqlStatementContext) + i++ + } + } + + return tst +} + +func (s *CaseStatementContext) ProcedureSqlStatement(i int) IProcedureSqlStatementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProcedureSqlStatementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IProcedureSqlStatementContext) +} + +func (s *CaseStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CaseStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CaseStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCaseStatement(s) + } +} + +func (s *CaseStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCaseStatement(s) + } +} + +func (p *MySqlParser) CaseStatement() (localctx ICaseStatementContext) { + localctx = NewCaseStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 392, MySqlParserRULE_caseStatement) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4756) + p.Match(MySqlParserCASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4759) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 690, p.GetParserRuleContext()) == 1 { + { + p.SetState(4757) + p.Uid() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 690, p.GetParserRuleContext()) == 2 { + { + p.SetState(4758) + p.expression(0) + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4762) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == MySqlParserWHEN { + { + p.SetState(4761) + p.CaseAlternative() + } + + p.SetState(4764) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(4772) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserELSE { + { + p.SetState(4766) + p.Match(MySqlParserELSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4768) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(4767) + p.ProcedureSqlStatement() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(4770) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 692, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + } + { + p.SetState(4774) + p.Match(MySqlParserEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4775) + p.Match(MySqlParserCASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIfStatementContext is an interface to support dynamic dispatch. +type IIfStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Get_procedureSqlStatement returns the _procedureSqlStatement rule contexts. + Get_procedureSqlStatement() IProcedureSqlStatementContext + + // Set_procedureSqlStatement sets the _procedureSqlStatement rule contexts. + Set_procedureSqlStatement(IProcedureSqlStatementContext) + + // GetThenStatements returns the thenStatements rule context list. + GetThenStatements() []IProcedureSqlStatementContext + + // GetElseStatements returns the elseStatements rule context list. + GetElseStatements() []IProcedureSqlStatementContext + + // SetThenStatements sets the thenStatements rule context list. + SetThenStatements([]IProcedureSqlStatementContext) + + // SetElseStatements sets the elseStatements rule context list. + SetElseStatements([]IProcedureSqlStatementContext) + + // Getter signatures + AllIF() []antlr.TerminalNode + IF(i int) antlr.TerminalNode + Expression() IExpressionContext + THEN() antlr.TerminalNode + END() antlr.TerminalNode + AllElifAlternative() []IElifAlternativeContext + ElifAlternative(i int) IElifAlternativeContext + ELSE() antlr.TerminalNode + AllProcedureSqlStatement() []IProcedureSqlStatementContext + ProcedureSqlStatement(i int) IProcedureSqlStatementContext + + // IsIfStatementContext differentiates from other interfaces. + IsIfStatementContext() +} + +type IfStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + _procedureSqlStatement IProcedureSqlStatementContext + thenStatements []IProcedureSqlStatementContext + elseStatements []IProcedureSqlStatementContext +} + +func NewEmptyIfStatementContext() *IfStatementContext { + var p = new(IfStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_ifStatement + return p +} + +func InitEmptyIfStatementContext(p *IfStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_ifStatement +} + +func (*IfStatementContext) IsIfStatementContext() {} + +func NewIfStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IfStatementContext { + var p = new(IfStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_ifStatement + + return p +} + +func (s *IfStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *IfStatementContext) Get_procedureSqlStatement() IProcedureSqlStatementContext { + return s._procedureSqlStatement +} + +func (s *IfStatementContext) Set_procedureSqlStatement(v IProcedureSqlStatementContext) { + s._procedureSqlStatement = v +} + +func (s *IfStatementContext) GetThenStatements() []IProcedureSqlStatementContext { + return s.thenStatements +} + +func (s *IfStatementContext) GetElseStatements() []IProcedureSqlStatementContext { + return s.elseStatements +} + +func (s *IfStatementContext) SetThenStatements(v []IProcedureSqlStatementContext) { + s.thenStatements = v +} + +func (s *IfStatementContext) SetElseStatements(v []IProcedureSqlStatementContext) { + s.elseStatements = v +} + +func (s *IfStatementContext) AllIF() []antlr.TerminalNode { + return s.GetTokens(MySqlParserIF) +} + +func (s *IfStatementContext) IF(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserIF, i) +} + +func (s *IfStatementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *IfStatementContext) THEN() antlr.TerminalNode { + return s.GetToken(MySqlParserTHEN, 0) +} + +func (s *IfStatementContext) END() antlr.TerminalNode { + return s.GetToken(MySqlParserEND, 0) +} + +func (s *IfStatementContext) AllElifAlternative() []IElifAlternativeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IElifAlternativeContext); ok { + len++ + } + } + + tst := make([]IElifAlternativeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IElifAlternativeContext); ok { + tst[i] = t.(IElifAlternativeContext) + i++ + } + } + + return tst +} + +func (s *IfStatementContext) ElifAlternative(i int) IElifAlternativeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IElifAlternativeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IElifAlternativeContext) +} + +func (s *IfStatementContext) ELSE() antlr.TerminalNode { + return s.GetToken(MySqlParserELSE, 0) +} + +func (s *IfStatementContext) AllProcedureSqlStatement() []IProcedureSqlStatementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IProcedureSqlStatementContext); ok { + len++ + } + } + + tst := make([]IProcedureSqlStatementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IProcedureSqlStatementContext); ok { + tst[i] = t.(IProcedureSqlStatementContext) + i++ + } + } + + return tst +} + +func (s *IfStatementContext) ProcedureSqlStatement(i int) IProcedureSqlStatementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProcedureSqlStatementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IProcedureSqlStatementContext) +} + +func (s *IfStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IfStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IfStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterIfStatement(s) + } +} + +func (s *IfStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitIfStatement(s) + } +} + +func (p *MySqlParser) IfStatement() (localctx IIfStatementContext) { + localctx = NewIfStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 394, MySqlParserRULE_ifStatement) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4777) + p.Match(MySqlParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4778) + p.expression(0) + } + { + p.SetState(4779) + p.Match(MySqlParserTHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4781) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(4780) + + var _x = p.ProcedureSqlStatement() + + localctx.(*IfStatementContext)._procedureSqlStatement = _x + } + localctx.(*IfStatementContext).thenStatements = append(localctx.(*IfStatementContext).thenStatements, localctx.(*IfStatementContext)._procedureSqlStatement) + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(4783) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 694, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(4788) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserELSEIF { + { + p.SetState(4785) + p.ElifAlternative() + } + + p.SetState(4790) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(4797) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserELSE { + { + p.SetState(4791) + p.Match(MySqlParserELSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4793) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(4792) + + var _x = p.ProcedureSqlStatement() + + localctx.(*IfStatementContext)._procedureSqlStatement = _x + } + localctx.(*IfStatementContext).elseStatements = append(localctx.(*IfStatementContext).elseStatements, localctx.(*IfStatementContext)._procedureSqlStatement) + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(4795) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 696, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + } + { + p.SetState(4799) + p.Match(MySqlParserEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4800) + p.Match(MySqlParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIterateStatementContext is an interface to support dynamic dispatch. +type IIterateStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ITERATE() antlr.TerminalNode + Uid() IUidContext + + // IsIterateStatementContext differentiates from other interfaces. + IsIterateStatementContext() +} + +type IterateStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIterateStatementContext() *IterateStatementContext { + var p = new(IterateStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_iterateStatement + return p +} + +func InitEmptyIterateStatementContext(p *IterateStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_iterateStatement +} + +func (*IterateStatementContext) IsIterateStatementContext() {} + +func NewIterateStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IterateStatementContext { + var p = new(IterateStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_iterateStatement + + return p +} + +func (s *IterateStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *IterateStatementContext) ITERATE() antlr.TerminalNode { + return s.GetToken(MySqlParserITERATE, 0) +} + +func (s *IterateStatementContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *IterateStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IterateStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IterateStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterIterateStatement(s) + } +} + +func (s *IterateStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitIterateStatement(s) + } +} + +func (p *MySqlParser) IterateStatement() (localctx IIterateStatementContext) { + localctx = NewIterateStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 396, MySqlParserRULE_iterateStatement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4802) + p.Match(MySqlParserITERATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4803) + p.Uid() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILeaveStatementContext is an interface to support dynamic dispatch. +type ILeaveStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEAVE() antlr.TerminalNode + Uid() IUidContext + + // IsLeaveStatementContext differentiates from other interfaces. + IsLeaveStatementContext() +} + +type LeaveStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLeaveStatementContext() *LeaveStatementContext { + var p = new(LeaveStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_leaveStatement + return p +} + +func InitEmptyLeaveStatementContext(p *LeaveStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_leaveStatement +} + +func (*LeaveStatementContext) IsLeaveStatementContext() {} + +func NewLeaveStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LeaveStatementContext { + var p = new(LeaveStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_leaveStatement + + return p +} + +func (s *LeaveStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *LeaveStatementContext) LEAVE() antlr.TerminalNode { + return s.GetToken(MySqlParserLEAVE, 0) +} + +func (s *LeaveStatementContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *LeaveStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LeaveStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *LeaveStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterLeaveStatement(s) + } +} + +func (s *LeaveStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitLeaveStatement(s) + } +} + +func (p *MySqlParser) LeaveStatement() (localctx ILeaveStatementContext) { + localctx = NewLeaveStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 398, MySqlParserRULE_leaveStatement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4805) + p.Match(MySqlParserLEAVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4806) + p.Uid() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILoopStatementContext is an interface to support dynamic dispatch. +type ILoopStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllLOOP() []antlr.TerminalNode + LOOP(i int) antlr.TerminalNode + END() antlr.TerminalNode + AllUid() []IUidContext + Uid(i int) IUidContext + COLON_SYMB() antlr.TerminalNode + AllProcedureSqlStatement() []IProcedureSqlStatementContext + ProcedureSqlStatement(i int) IProcedureSqlStatementContext + + // IsLoopStatementContext differentiates from other interfaces. + IsLoopStatementContext() +} + +type LoopStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLoopStatementContext() *LoopStatementContext { + var p = new(LoopStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_loopStatement + return p +} + +func InitEmptyLoopStatementContext(p *LoopStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_loopStatement +} + +func (*LoopStatementContext) IsLoopStatementContext() {} + +func NewLoopStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LoopStatementContext { + var p = new(LoopStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_loopStatement + + return p +} + +func (s *LoopStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *LoopStatementContext) AllLOOP() []antlr.TerminalNode { + return s.GetTokens(MySqlParserLOOP) +} + +func (s *LoopStatementContext) LOOP(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserLOOP, i) +} + +func (s *LoopStatementContext) END() antlr.TerminalNode { + return s.GetToken(MySqlParserEND, 0) +} + +func (s *LoopStatementContext) AllUid() []IUidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUidContext); ok { + len++ + } + } + + tst := make([]IUidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUidContext); ok { + tst[i] = t.(IUidContext) + i++ + } + } + + return tst +} + +func (s *LoopStatementContext) Uid(i int) IUidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *LoopStatementContext) COLON_SYMB() antlr.TerminalNode { + return s.GetToken(MySqlParserCOLON_SYMB, 0) +} + +func (s *LoopStatementContext) AllProcedureSqlStatement() []IProcedureSqlStatementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IProcedureSqlStatementContext); ok { + len++ + } + } + + tst := make([]IProcedureSqlStatementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IProcedureSqlStatementContext); ok { + tst[i] = t.(IProcedureSqlStatementContext) + i++ + } + } + + return tst +} + +func (s *LoopStatementContext) ProcedureSqlStatement(i int) IProcedureSqlStatementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProcedureSqlStatementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IProcedureSqlStatementContext) +} + +func (s *LoopStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LoopStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *LoopStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterLoopStatement(s) + } +} + +func (s *LoopStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitLoopStatement(s) + } +} + +func (p *MySqlParser) LoopStatement() (localctx ILoopStatementContext) { + localctx = NewLoopStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 400, MySqlParserRULE_loopStatement) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(4811) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-34354363873) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-2199023255553) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-5764611921080745985) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-8796126576641) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-32651097298436097) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-18014398517872129) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-137438953601) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-44473063500156929) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-129) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-12289) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&-1) != 0) || ((int64((_la-1128)) & ^0x3f) == 0 && ((int64(1)<<(_la-1128))&8627683329) != 0) { + { + p.SetState(4808) + p.Uid() + } + { + p.SetState(4809) + p.Match(MySqlParserCOLON_SYMB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4813) + p.Match(MySqlParserLOOP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4815) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(4814) + p.ProcedureSqlStatement() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(4817) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 699, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + { + p.SetState(4819) + p.Match(MySqlParserEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4820) + p.Match(MySqlParserLOOP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4822) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-34354363873) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-2199023255553) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-5764611921080745985) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-8796126576641) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-32651097298436097) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-18014398517872129) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-137438953601) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-44473063500156929) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-129) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-12289) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&-1) != 0) || ((int64((_la-1128)) & ^0x3f) == 0 && ((int64(1)<<(_la-1128))&8627683329) != 0) { + { + p.SetState(4821) + p.Uid() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRepeatStatementContext is an interface to support dynamic dispatch. +type IRepeatStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllREPEAT() []antlr.TerminalNode + REPEAT(i int) antlr.TerminalNode + UNTIL() antlr.TerminalNode + Expression() IExpressionContext + END() antlr.TerminalNode + AllUid() []IUidContext + Uid(i int) IUidContext + COLON_SYMB() antlr.TerminalNode + AllProcedureSqlStatement() []IProcedureSqlStatementContext + ProcedureSqlStatement(i int) IProcedureSqlStatementContext + + // IsRepeatStatementContext differentiates from other interfaces. + IsRepeatStatementContext() +} + +type RepeatStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRepeatStatementContext() *RepeatStatementContext { + var p = new(RepeatStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_repeatStatement + return p +} + +func InitEmptyRepeatStatementContext(p *RepeatStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_repeatStatement +} + +func (*RepeatStatementContext) IsRepeatStatementContext() {} + +func NewRepeatStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RepeatStatementContext { + var p = new(RepeatStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_repeatStatement + + return p +} + +func (s *RepeatStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *RepeatStatementContext) AllREPEAT() []antlr.TerminalNode { + return s.GetTokens(MySqlParserREPEAT) +} + +func (s *RepeatStatementContext) REPEAT(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserREPEAT, i) +} + +func (s *RepeatStatementContext) UNTIL() antlr.TerminalNode { + return s.GetToken(MySqlParserUNTIL, 0) +} + +func (s *RepeatStatementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *RepeatStatementContext) END() antlr.TerminalNode { + return s.GetToken(MySqlParserEND, 0) +} + +func (s *RepeatStatementContext) AllUid() []IUidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUidContext); ok { + len++ + } + } + + tst := make([]IUidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUidContext); ok { + tst[i] = t.(IUidContext) + i++ + } + } + + return tst +} + +func (s *RepeatStatementContext) Uid(i int) IUidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *RepeatStatementContext) COLON_SYMB() antlr.TerminalNode { + return s.GetToken(MySqlParserCOLON_SYMB, 0) +} + +func (s *RepeatStatementContext) AllProcedureSqlStatement() []IProcedureSqlStatementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IProcedureSqlStatementContext); ok { + len++ + } + } + + tst := make([]IProcedureSqlStatementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IProcedureSqlStatementContext); ok { + tst[i] = t.(IProcedureSqlStatementContext) + i++ + } + } + + return tst +} + +func (s *RepeatStatementContext) ProcedureSqlStatement(i int) IProcedureSqlStatementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProcedureSqlStatementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IProcedureSqlStatementContext) +} + +func (s *RepeatStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RepeatStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RepeatStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterRepeatStatement(s) + } +} + +func (s *RepeatStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitRepeatStatement(s) + } +} + +func (p *MySqlParser) RepeatStatement() (localctx IRepeatStatementContext) { + localctx = NewRepeatStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 402, MySqlParserRULE_repeatStatement) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(4827) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 701, p.GetParserRuleContext()) == 1 { + { + p.SetState(4824) + p.Uid() + } + { + p.SetState(4825) + p.Match(MySqlParserCOLON_SYMB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4829) + p.Match(MySqlParserREPEAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4831) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(4830) + p.ProcedureSqlStatement() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(4833) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 702, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + { + p.SetState(4835) + p.Match(MySqlParserUNTIL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4836) + p.expression(0) + } + { + p.SetState(4837) + p.Match(MySqlParserEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4838) + p.Match(MySqlParserREPEAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4840) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-34354363873) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-2199023255553) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-5764611921080745985) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-8796126576641) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-32651097298436097) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-18014398517872129) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-137438953601) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-44473063500156929) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-129) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-12289) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&-1) != 0) || ((int64((_la-1128)) & ^0x3f) == 0 && ((int64(1)<<(_la-1128))&8627683329) != 0) { + { + p.SetState(4839) + p.Uid() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReturnStatementContext is an interface to support dynamic dispatch. +type IReturnStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RETURN() antlr.TerminalNode + Expression() IExpressionContext + + // IsReturnStatementContext differentiates from other interfaces. + IsReturnStatementContext() +} + +type ReturnStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReturnStatementContext() *ReturnStatementContext { + var p = new(ReturnStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_returnStatement + return p +} + +func InitEmptyReturnStatementContext(p *ReturnStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_returnStatement +} + +func (*ReturnStatementContext) IsReturnStatementContext() {} + +func NewReturnStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReturnStatementContext { + var p = new(ReturnStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_returnStatement + + return p +} + +func (s *ReturnStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *ReturnStatementContext) RETURN() antlr.TerminalNode { + return s.GetToken(MySqlParserRETURN, 0) +} + +func (s *ReturnStatementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *ReturnStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ReturnStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ReturnStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterReturnStatement(s) + } +} + +func (s *ReturnStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitReturnStatement(s) + } +} + +func (p *MySqlParser) ReturnStatement() (localctx IReturnStatementContext) { + localctx = NewReturnStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 404, MySqlParserRULE_returnStatement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4842) + p.Match(MySqlParserRETURN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4843) + p.expression(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWhileStatementContext is an interface to support dynamic dispatch. +type IWhileStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllWHILE() []antlr.TerminalNode + WHILE(i int) antlr.TerminalNode + Expression() IExpressionContext + DO() antlr.TerminalNode + END() antlr.TerminalNode + AllUid() []IUidContext + Uid(i int) IUidContext + COLON_SYMB() antlr.TerminalNode + AllProcedureSqlStatement() []IProcedureSqlStatementContext + ProcedureSqlStatement(i int) IProcedureSqlStatementContext + + // IsWhileStatementContext differentiates from other interfaces. + IsWhileStatementContext() +} + +type WhileStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWhileStatementContext() *WhileStatementContext { + var p = new(WhileStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_whileStatement + return p +} + +func InitEmptyWhileStatementContext(p *WhileStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_whileStatement +} + +func (*WhileStatementContext) IsWhileStatementContext() {} + +func NewWhileStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WhileStatementContext { + var p = new(WhileStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_whileStatement + + return p +} + +func (s *WhileStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *WhileStatementContext) AllWHILE() []antlr.TerminalNode { + return s.GetTokens(MySqlParserWHILE) +} + +func (s *WhileStatementContext) WHILE(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserWHILE, i) +} + +func (s *WhileStatementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *WhileStatementContext) DO() antlr.TerminalNode { + return s.GetToken(MySqlParserDO, 0) +} + +func (s *WhileStatementContext) END() antlr.TerminalNode { + return s.GetToken(MySqlParserEND, 0) +} + +func (s *WhileStatementContext) AllUid() []IUidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUidContext); ok { + len++ + } + } + + tst := make([]IUidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUidContext); ok { + tst[i] = t.(IUidContext) + i++ + } + } + + return tst +} + +func (s *WhileStatementContext) Uid(i int) IUidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *WhileStatementContext) COLON_SYMB() antlr.TerminalNode { + return s.GetToken(MySqlParserCOLON_SYMB, 0) +} + +func (s *WhileStatementContext) AllProcedureSqlStatement() []IProcedureSqlStatementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IProcedureSqlStatementContext); ok { + len++ + } + } + + tst := make([]IProcedureSqlStatementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IProcedureSqlStatementContext); ok { + tst[i] = t.(IProcedureSqlStatementContext) + i++ + } + } + + return tst +} + +func (s *WhileStatementContext) ProcedureSqlStatement(i int) IProcedureSqlStatementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProcedureSqlStatementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IProcedureSqlStatementContext) +} + +func (s *WhileStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *WhileStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *WhileStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterWhileStatement(s) + } +} + +func (s *WhileStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitWhileStatement(s) + } +} + +func (p *MySqlParser) WhileStatement() (localctx IWhileStatementContext) { + localctx = NewWhileStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 406, MySqlParserRULE_whileStatement) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(4848) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-34354363873) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-2199023255553) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-5764611921080745985) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-8796126576641) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-32651097298436097) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-18014398517872129) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-137438953601) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-44473063500156929) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-129) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-12289) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&-1) != 0) || ((int64((_la-1128)) & ^0x3f) == 0 && ((int64(1)<<(_la-1128))&8627683329) != 0) { + { + p.SetState(4845) + p.Uid() + } + { + p.SetState(4846) + p.Match(MySqlParserCOLON_SYMB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4850) + p.Match(MySqlParserWHILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4851) + p.expression(0) + } + { + p.SetState(4852) + p.Match(MySqlParserDO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4854) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(4853) + p.ProcedureSqlStatement() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(4856) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 705, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + { + p.SetState(4858) + p.Match(MySqlParserEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4859) + p.Match(MySqlParserWHILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4861) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-34354363873) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-2199023255553) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-5764611921080745985) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-8796126576641) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-32651097298436097) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-18014398517872129) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-137438953601) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-44473063500156929) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-129) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-12289) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&-1) != 0) || ((int64((_la-1128)) & ^0x3f) == 0 && ((int64(1)<<(_la-1128))&8627683329) != 0) { + { + p.SetState(4860) + p.Uid() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICursorStatementContext is an interface to support dynamic dispatch. +type ICursorStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsCursorStatementContext differentiates from other interfaces. + IsCursorStatementContext() +} + +type CursorStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCursorStatementContext() *CursorStatementContext { + var p = new(CursorStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_cursorStatement + return p +} + +func InitEmptyCursorStatementContext(p *CursorStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_cursorStatement +} + +func (*CursorStatementContext) IsCursorStatementContext() {} + +func NewCursorStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CursorStatementContext { + var p = new(CursorStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_cursorStatement + + return p +} + +func (s *CursorStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *CursorStatementContext) CopyAll(ctx *CursorStatementContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *CursorStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CursorStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type CloseCursorContext struct { + CursorStatementContext +} + +func NewCloseCursorContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CloseCursorContext { + var p = new(CloseCursorContext) + + InitEmptyCursorStatementContext(&p.CursorStatementContext) + p.parser = parser + p.CopyAll(ctx.(*CursorStatementContext)) + + return p +} + +func (s *CloseCursorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CloseCursorContext) CLOSE() antlr.TerminalNode { + return s.GetToken(MySqlParserCLOSE, 0) +} + +func (s *CloseCursorContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *CloseCursorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCloseCursor(s) + } +} + +func (s *CloseCursorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCloseCursor(s) + } +} + +type OpenCursorContext struct { + CursorStatementContext +} + +func NewOpenCursorContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *OpenCursorContext { + var p = new(OpenCursorContext) + + InitEmptyCursorStatementContext(&p.CursorStatementContext) + p.parser = parser + p.CopyAll(ctx.(*CursorStatementContext)) + + return p +} + +func (s *OpenCursorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *OpenCursorContext) OPEN() antlr.TerminalNode { + return s.GetToken(MySqlParserOPEN, 0) +} + +func (s *OpenCursorContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *OpenCursorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterOpenCursor(s) + } +} + +func (s *OpenCursorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitOpenCursor(s) + } +} + +type FetchCursorContext struct { + CursorStatementContext +} + +func NewFetchCursorContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *FetchCursorContext { + var p = new(FetchCursorContext) + + InitEmptyCursorStatementContext(&p.CursorStatementContext) + p.parser = parser + p.CopyAll(ctx.(*CursorStatementContext)) + + return p +} + +func (s *FetchCursorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FetchCursorContext) FETCH() antlr.TerminalNode { + return s.GetToken(MySqlParserFETCH, 0) +} + +func (s *FetchCursorContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *FetchCursorContext) INTO() antlr.TerminalNode { + return s.GetToken(MySqlParserINTO, 0) +} + +func (s *FetchCursorContext) UidList() IUidListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidListContext) +} + +func (s *FetchCursorContext) FROM() antlr.TerminalNode { + return s.GetToken(MySqlParserFROM, 0) +} + +func (s *FetchCursorContext) NEXT() antlr.TerminalNode { + return s.GetToken(MySqlParserNEXT, 0) +} + +func (s *FetchCursorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterFetchCursor(s) + } +} + +func (s *FetchCursorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitFetchCursor(s) + } +} + +func (p *MySqlParser) CursorStatement() (localctx ICursorStatementContext) { + localctx = NewCursorStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 408, MySqlParserRULE_cursorStatement) + var _la int + + p.SetState(4878) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserCLOSE: + localctx = NewCloseCursorContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4863) + p.Match(MySqlParserCLOSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4864) + p.Uid() + } + + case MySqlParserFETCH: + localctx = NewFetchCursorContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4865) + p.Match(MySqlParserFETCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4870) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 708, p.GetParserRuleContext()) == 1 { + p.SetState(4867) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserNEXT { + { + p.SetState(4866) + p.Match(MySqlParserNEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4869) + p.Match(MySqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4872) + p.Uid() + } + { + p.SetState(4873) + p.Match(MySqlParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4874) + p.UidList() + } + + case MySqlParserOPEN: + localctx = NewOpenCursorContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4876) + p.Match(MySqlParserOPEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4877) + p.Uid() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDeclareVariableContext is an interface to support dynamic dispatch. +type IDeclareVariableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DECLARE() antlr.TerminalNode + UidList() IUidListContext + DataType() IDataTypeContext + DEFAULT() antlr.TerminalNode + Expression() IExpressionContext + + // IsDeclareVariableContext differentiates from other interfaces. + IsDeclareVariableContext() +} + +type DeclareVariableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDeclareVariableContext() *DeclareVariableContext { + var p = new(DeclareVariableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_declareVariable + return p +} + +func InitEmptyDeclareVariableContext(p *DeclareVariableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_declareVariable +} + +func (*DeclareVariableContext) IsDeclareVariableContext() {} + +func NewDeclareVariableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DeclareVariableContext { + var p = new(DeclareVariableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_declareVariable + + return p +} + +func (s *DeclareVariableContext) GetParser() antlr.Parser { return s.parser } + +func (s *DeclareVariableContext) DECLARE() antlr.TerminalNode { + return s.GetToken(MySqlParserDECLARE, 0) +} + +func (s *DeclareVariableContext) UidList() IUidListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidListContext) +} + +func (s *DeclareVariableContext) DataType() IDataTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDataTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDataTypeContext) +} + +func (s *DeclareVariableContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(MySqlParserDEFAULT, 0) +} + +func (s *DeclareVariableContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *DeclareVariableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DeclareVariableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DeclareVariableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterDeclareVariable(s) + } +} + +func (s *DeclareVariableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitDeclareVariable(s) + } +} + +func (p *MySqlParser) DeclareVariable() (localctx IDeclareVariableContext) { + localctx = NewDeclareVariableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 410, MySqlParserRULE_declareVariable) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4880) + p.Match(MySqlParserDECLARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4881) + p.UidList() + } + { + p.SetState(4882) + p.DataType() + } + p.SetState(4885) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserDEFAULT { + { + p.SetState(4883) + p.Match(MySqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4884) + p.expression(0) + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDeclareConditionContext is an interface to support dynamic dispatch. +type IDeclareConditionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DECLARE() antlr.TerminalNode + Uid() IUidContext + CONDITION() antlr.TerminalNode + FOR() antlr.TerminalNode + DecimalLiteral() IDecimalLiteralContext + SQLSTATE() antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + VALUE() antlr.TerminalNode + + // IsDeclareConditionContext differentiates from other interfaces. + IsDeclareConditionContext() +} + +type DeclareConditionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDeclareConditionContext() *DeclareConditionContext { + var p = new(DeclareConditionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_declareCondition + return p +} + +func InitEmptyDeclareConditionContext(p *DeclareConditionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_declareCondition +} + +func (*DeclareConditionContext) IsDeclareConditionContext() {} + +func NewDeclareConditionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DeclareConditionContext { + var p = new(DeclareConditionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_declareCondition + + return p +} + +func (s *DeclareConditionContext) GetParser() antlr.Parser { return s.parser } + +func (s *DeclareConditionContext) DECLARE() antlr.TerminalNode { + return s.GetToken(MySqlParserDECLARE, 0) +} + +func (s *DeclareConditionContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *DeclareConditionContext) CONDITION() antlr.TerminalNode { + return s.GetToken(MySqlParserCONDITION, 0) +} + +func (s *DeclareConditionContext) FOR() antlr.TerminalNode { + return s.GetToken(MySqlParserFOR, 0) +} + +func (s *DeclareConditionContext) DecimalLiteral() IDecimalLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *DeclareConditionContext) SQLSTATE() antlr.TerminalNode { + return s.GetToken(MySqlParserSQLSTATE, 0) +} + +func (s *DeclareConditionContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *DeclareConditionContext) VALUE() antlr.TerminalNode { + return s.GetToken(MySqlParserVALUE, 0) +} + +func (s *DeclareConditionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DeclareConditionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DeclareConditionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterDeclareCondition(s) + } +} + +func (s *DeclareConditionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitDeclareCondition(s) + } +} + +func (p *MySqlParser) DeclareCondition() (localctx IDeclareConditionContext) { + localctx = NewDeclareConditionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 412, MySqlParserRULE_declareCondition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4887) + p.Match(MySqlParserDECLARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4888) + p.Uid() + } + { + p.SetState(4889) + p.Match(MySqlParserCONDITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4890) + p.Match(MySqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4897) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserZERO_DECIMAL, MySqlParserONE_DECIMAL, MySqlParserTWO_DECIMAL, MySqlParserDECIMAL_LITERAL, MySqlParserREAL_LITERAL: + { + p.SetState(4891) + p.DecimalLiteral() + } + + case MySqlParserSQLSTATE: + { + p.SetState(4892) + p.Match(MySqlParserSQLSTATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4894) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserVALUE { + { + p.SetState(4893) + p.Match(MySqlParserVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4896) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDeclareCursorContext is an interface to support dynamic dispatch. +type IDeclareCursorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DECLARE() antlr.TerminalNode + Uid() IUidContext + CURSOR() antlr.TerminalNode + FOR() antlr.TerminalNode + SelectStatement() ISelectStatementContext + + // IsDeclareCursorContext differentiates from other interfaces. + IsDeclareCursorContext() +} + +type DeclareCursorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDeclareCursorContext() *DeclareCursorContext { + var p = new(DeclareCursorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_declareCursor + return p +} + +func InitEmptyDeclareCursorContext(p *DeclareCursorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_declareCursor +} + +func (*DeclareCursorContext) IsDeclareCursorContext() {} + +func NewDeclareCursorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DeclareCursorContext { + var p = new(DeclareCursorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_declareCursor + + return p +} + +func (s *DeclareCursorContext) GetParser() antlr.Parser { return s.parser } + +func (s *DeclareCursorContext) DECLARE() antlr.TerminalNode { + return s.GetToken(MySqlParserDECLARE, 0) +} + +func (s *DeclareCursorContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *DeclareCursorContext) CURSOR() antlr.TerminalNode { + return s.GetToken(MySqlParserCURSOR, 0) +} + +func (s *DeclareCursorContext) FOR() antlr.TerminalNode { + return s.GetToken(MySqlParserFOR, 0) +} + +func (s *DeclareCursorContext) SelectStatement() ISelectStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelectStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelectStatementContext) +} + +func (s *DeclareCursorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DeclareCursorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DeclareCursorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterDeclareCursor(s) + } +} + +func (s *DeclareCursorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitDeclareCursor(s) + } +} + +func (p *MySqlParser) DeclareCursor() (localctx IDeclareCursorContext) { + localctx = NewDeclareCursorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 414, MySqlParserRULE_declareCursor) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4899) + p.Match(MySqlParserDECLARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4900) + p.Uid() + } + { + p.SetState(4901) + p.Match(MySqlParserCURSOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4902) + p.Match(MySqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4903) + p.SelectStatement() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDeclareHandlerContext is an interface to support dynamic dispatch. +type IDeclareHandlerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetHandlerAction returns the handlerAction token. + GetHandlerAction() antlr.Token + + // SetHandlerAction sets the handlerAction token. + SetHandlerAction(antlr.Token) + + // Getter signatures + DECLARE() antlr.TerminalNode + HANDLER() antlr.TerminalNode + FOR() antlr.TerminalNode + AllHandlerConditionValue() []IHandlerConditionValueContext + HandlerConditionValue(i int) IHandlerConditionValueContext + RoutineBody() IRoutineBodyContext + CONTINUE() antlr.TerminalNode + EXIT() antlr.TerminalNode + UNDO() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsDeclareHandlerContext differentiates from other interfaces. + IsDeclareHandlerContext() +} + +type DeclareHandlerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + handlerAction antlr.Token +} + +func NewEmptyDeclareHandlerContext() *DeclareHandlerContext { + var p = new(DeclareHandlerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_declareHandler + return p +} + +func InitEmptyDeclareHandlerContext(p *DeclareHandlerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_declareHandler +} + +func (*DeclareHandlerContext) IsDeclareHandlerContext() {} + +func NewDeclareHandlerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DeclareHandlerContext { + var p = new(DeclareHandlerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_declareHandler + + return p +} + +func (s *DeclareHandlerContext) GetParser() antlr.Parser { return s.parser } + +func (s *DeclareHandlerContext) GetHandlerAction() antlr.Token { return s.handlerAction } + +func (s *DeclareHandlerContext) SetHandlerAction(v antlr.Token) { s.handlerAction = v } + +func (s *DeclareHandlerContext) DECLARE() antlr.TerminalNode { + return s.GetToken(MySqlParserDECLARE, 0) +} + +func (s *DeclareHandlerContext) HANDLER() antlr.TerminalNode { + return s.GetToken(MySqlParserHANDLER, 0) +} + +func (s *DeclareHandlerContext) FOR() antlr.TerminalNode { + return s.GetToken(MySqlParserFOR, 0) +} + +func (s *DeclareHandlerContext) AllHandlerConditionValue() []IHandlerConditionValueContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IHandlerConditionValueContext); ok { + len++ + } + } + + tst := make([]IHandlerConditionValueContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IHandlerConditionValueContext); ok { + tst[i] = t.(IHandlerConditionValueContext) + i++ + } + } + + return tst +} + +func (s *DeclareHandlerContext) HandlerConditionValue(i int) IHandlerConditionValueContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHandlerConditionValueContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IHandlerConditionValueContext) +} + +func (s *DeclareHandlerContext) RoutineBody() IRoutineBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRoutineBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRoutineBodyContext) +} + +func (s *DeclareHandlerContext) CONTINUE() antlr.TerminalNode { + return s.GetToken(MySqlParserCONTINUE, 0) +} + +func (s *DeclareHandlerContext) EXIT() antlr.TerminalNode { + return s.GetToken(MySqlParserEXIT, 0) +} + +func (s *DeclareHandlerContext) UNDO() antlr.TerminalNode { + return s.GetToken(MySqlParserUNDO, 0) +} + +func (s *DeclareHandlerContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *DeclareHandlerContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *DeclareHandlerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DeclareHandlerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DeclareHandlerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterDeclareHandler(s) + } +} + +func (s *DeclareHandlerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitDeclareHandler(s) + } +} + +func (p *MySqlParser) DeclareHandler() (localctx IDeclareHandlerContext) { + localctx = NewDeclareHandlerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 416, MySqlParserRULE_declareHandler) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4905) + p.Match(MySqlParserDECLARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4906) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*DeclareHandlerContext).handlerAction = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserCONTINUE || _la == MySqlParserEXIT || _la == MySqlParserUNDO) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*DeclareHandlerContext).handlerAction = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(4907) + p.Match(MySqlParserHANDLER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4908) + p.Match(MySqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4909) + p.HandlerConditionValue() + } + p.SetState(4914) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(4910) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4911) + p.HandlerConditionValue() + } + + p.SetState(4916) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(4917) + p.RoutineBody() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHandlerConditionValueContext is an interface to support dynamic dispatch. +type IHandlerConditionValueContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsHandlerConditionValueContext differentiates from other interfaces. + IsHandlerConditionValueContext() +} + +type HandlerConditionValueContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHandlerConditionValueContext() *HandlerConditionValueContext { + var p = new(HandlerConditionValueContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_handlerConditionValue + return p +} + +func InitEmptyHandlerConditionValueContext(p *HandlerConditionValueContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_handlerConditionValue +} + +func (*HandlerConditionValueContext) IsHandlerConditionValueContext() {} + +func NewHandlerConditionValueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *HandlerConditionValueContext { + var p = new(HandlerConditionValueContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_handlerConditionValue + + return p +} + +func (s *HandlerConditionValueContext) GetParser() antlr.Parser { return s.parser } + +func (s *HandlerConditionValueContext) CopyAll(ctx *HandlerConditionValueContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *HandlerConditionValueContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *HandlerConditionValueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type HandlerConditionWarningContext struct { + HandlerConditionValueContext +} + +func NewHandlerConditionWarningContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *HandlerConditionWarningContext { + var p = new(HandlerConditionWarningContext) + + InitEmptyHandlerConditionValueContext(&p.HandlerConditionValueContext) + p.parser = parser + p.CopyAll(ctx.(*HandlerConditionValueContext)) + + return p +} + +func (s *HandlerConditionWarningContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *HandlerConditionWarningContext) SQLWARNING() antlr.TerminalNode { + return s.GetToken(MySqlParserSQLWARNING, 0) +} + +func (s *HandlerConditionWarningContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterHandlerConditionWarning(s) + } +} + +func (s *HandlerConditionWarningContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitHandlerConditionWarning(s) + } +} + +type HandlerConditionCodeContext struct { + HandlerConditionValueContext +} + +func NewHandlerConditionCodeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *HandlerConditionCodeContext { + var p = new(HandlerConditionCodeContext) + + InitEmptyHandlerConditionValueContext(&p.HandlerConditionValueContext) + p.parser = parser + p.CopyAll(ctx.(*HandlerConditionValueContext)) + + return p +} + +func (s *HandlerConditionCodeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *HandlerConditionCodeContext) DecimalLiteral() IDecimalLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *HandlerConditionCodeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterHandlerConditionCode(s) + } +} + +func (s *HandlerConditionCodeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitHandlerConditionCode(s) + } +} + +type HandlerConditionNotfoundContext struct { + HandlerConditionValueContext +} + +func NewHandlerConditionNotfoundContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *HandlerConditionNotfoundContext { + var p = new(HandlerConditionNotfoundContext) + + InitEmptyHandlerConditionValueContext(&p.HandlerConditionValueContext) + p.parser = parser + p.CopyAll(ctx.(*HandlerConditionValueContext)) + + return p +} + +func (s *HandlerConditionNotfoundContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *HandlerConditionNotfoundContext) NOT() antlr.TerminalNode { + return s.GetToken(MySqlParserNOT, 0) +} + +func (s *HandlerConditionNotfoundContext) FOUND() antlr.TerminalNode { + return s.GetToken(MySqlParserFOUND, 0) +} + +func (s *HandlerConditionNotfoundContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterHandlerConditionNotfound(s) + } +} + +func (s *HandlerConditionNotfoundContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitHandlerConditionNotfound(s) + } +} + +type HandlerConditionStateContext struct { + HandlerConditionValueContext +} + +func NewHandlerConditionStateContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *HandlerConditionStateContext { + var p = new(HandlerConditionStateContext) + + InitEmptyHandlerConditionValueContext(&p.HandlerConditionValueContext) + p.parser = parser + p.CopyAll(ctx.(*HandlerConditionValueContext)) + + return p +} + +func (s *HandlerConditionStateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *HandlerConditionStateContext) SQLSTATE() antlr.TerminalNode { + return s.GetToken(MySqlParserSQLSTATE, 0) +} + +func (s *HandlerConditionStateContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *HandlerConditionStateContext) VALUE() antlr.TerminalNode { + return s.GetToken(MySqlParserVALUE, 0) +} + +func (s *HandlerConditionStateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterHandlerConditionState(s) + } +} + +func (s *HandlerConditionStateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitHandlerConditionState(s) + } +} + +type HandlerConditionExceptionContext struct { + HandlerConditionValueContext +} + +func NewHandlerConditionExceptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *HandlerConditionExceptionContext { + var p = new(HandlerConditionExceptionContext) + + InitEmptyHandlerConditionValueContext(&p.HandlerConditionValueContext) + p.parser = parser + p.CopyAll(ctx.(*HandlerConditionValueContext)) + + return p +} + +func (s *HandlerConditionExceptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *HandlerConditionExceptionContext) SQLEXCEPTION() antlr.TerminalNode { + return s.GetToken(MySqlParserSQLEXCEPTION, 0) +} + +func (s *HandlerConditionExceptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterHandlerConditionException(s) + } +} + +func (s *HandlerConditionExceptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitHandlerConditionException(s) + } +} + +type HandlerConditionNameContext struct { + HandlerConditionValueContext +} + +func NewHandlerConditionNameContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *HandlerConditionNameContext { + var p = new(HandlerConditionNameContext) + + InitEmptyHandlerConditionValueContext(&p.HandlerConditionValueContext) + p.parser = parser + p.CopyAll(ctx.(*HandlerConditionValueContext)) + + return p +} + +func (s *HandlerConditionNameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *HandlerConditionNameContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *HandlerConditionNameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterHandlerConditionName(s) + } +} + +func (s *HandlerConditionNameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitHandlerConditionName(s) + } +} + +func (p *MySqlParser) HandlerConditionValue() (localctx IHandlerConditionValueContext) { + localctx = NewHandlerConditionValueContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 418, MySqlParserRULE_handlerConditionValue) + var _la int + + p.SetState(4930) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserZERO_DECIMAL, MySqlParserONE_DECIMAL, MySqlParserTWO_DECIMAL, MySqlParserDECIMAL_LITERAL, MySqlParserREAL_LITERAL: + localctx = NewHandlerConditionCodeContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4919) + p.DecimalLiteral() + } + + case MySqlParserSQLSTATE: + localctx = NewHandlerConditionStateContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4920) + p.Match(MySqlParserSQLSTATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4922) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserVALUE { + { + p.SetState(4921) + p.Match(MySqlParserVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4924) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserARRAY, MySqlParserATTRIBUTE, MySqlParserBUCKETS, MySqlParserCONDITION, MySqlParserCURRENT, MySqlParserCURRENT_USER, MySqlParserDATABASE, MySqlParserDEFAULT, MySqlParserDIAGNOSTICS, MySqlParserEMPTY, MySqlParserENFORCED, MySqlParserEXCEPT, MySqlParserGROUP, MySqlParserIF, MySqlParserIGNORED, MySqlParserINSERT, MySqlParserLATERAL, MySqlParserLEFT, MySqlParserNUMBER, MySqlParserOPTIONAL, MySqlParserORDER, MySqlParserPRIMARY, MySqlParserREPEAT, MySqlParserREPLACE, MySqlParserRIGHT, MySqlParserSCHEMA, MySqlParserSKIP_QUERY_REWRITE, MySqlParserSTACKED, MySqlParserSTATEMENT, MySqlParserDATE, MySqlParserTIME, MySqlParserTIMESTAMP, MySqlParserDATETIME, MySqlParserYEAR, MySqlParserBINARY, MySqlParserTEXT, MySqlParserENUM, MySqlParserSERIAL, MySqlParserJSON_ARRAY, MySqlParserJSON_ARRAYAGG, MySqlParserJSON_ARRAY_APPEND, MySqlParserJSON_ARRAY_INSERT, MySqlParserJSON_CONTAINS, MySqlParserJSON_CONTAINS_PATH, MySqlParserJSON_DEPTH, MySqlParserJSON_EXTRACT, MySqlParserJSON_INSERT, MySqlParserJSON_KEYS, MySqlParserJSON_LENGTH, MySqlParserJSON_MERGE, MySqlParserJSON_MERGE_PATCH, MySqlParserJSON_MERGE_PRESERVE, MySqlParserJSON_OBJECT, MySqlParserJSON_OBJECTAGG, MySqlParserJSON_OVERLAPS, MySqlParserJSON_PRETTY, MySqlParserJSON_QUOTE, MySqlParserJSON_REMOVE, MySqlParserJSON_REPLACE, MySqlParserJSON_SCHEMA_VALID, MySqlParserJSON_SCHEMA_VALIDATION_REPORT, MySqlParserJSON_SEARCH, MySqlParserJSON_SET, MySqlParserJSON_STORAGE_FREE, MySqlParserJSON_STORAGE_SIZE, MySqlParserJSON_TABLE, MySqlParserJSON_TYPE, MySqlParserJSON_UNQUOTE, MySqlParserJSON_VALID, MySqlParserJSON_VALUE, MySqlParserNESTED, MySqlParserORDINALITY, MySqlParserPATH, MySqlParserAVG, MySqlParserBIT_AND, MySqlParserBIT_OR, MySqlParserBIT_XOR, MySqlParserCOUNT, MySqlParserCUME_DIST, MySqlParserDENSE_RANK, MySqlParserFIRST_VALUE, MySqlParserGROUP_CONCAT, MySqlParserLAG, MySqlParserLAST_VALUE, MySqlParserLEAD, MySqlParserMAX, MySqlParserMIN, MySqlParserNTILE, MySqlParserNTH_VALUE, MySqlParserPERCENT_RANK, MySqlParserRANK, MySqlParserROW_NUMBER, MySqlParserSTD, MySqlParserSTDDEV, MySqlParserSTDDEV_POP, MySqlParserSTDDEV_SAMP, MySqlParserSUM, MySqlParserVAR_POP, MySqlParserVAR_SAMP, MySqlParserVARIANCE, MySqlParserCURRENT_DATE, MySqlParserCURRENT_TIME, MySqlParserCURRENT_TIMESTAMP, MySqlParserLOCALTIME, MySqlParserCURDATE, MySqlParserCURTIME, MySqlParserDATE_ADD, MySqlParserDATE_SUB, MySqlParserLOCALTIMESTAMP, MySqlParserNOW, MySqlParserPOSITION, MySqlParserSUBSTR, MySqlParserSUBSTRING, MySqlParserSYSDATE, MySqlParserTRIM, MySqlParserUTC_DATE, MySqlParserUTC_TIME, MySqlParserUTC_TIMESTAMP, MySqlParserACCOUNT, MySqlParserACTION, MySqlParserAFTER, MySqlParserAGGREGATE, MySqlParserALGORITHM, MySqlParserANY, MySqlParserAT, MySqlParserAUTHORS, MySqlParserAUTOCOMMIT, MySqlParserAUTOEXTEND_SIZE, MySqlParserAUTO_INCREMENT, MySqlParserAVG_ROW_LENGTH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserBIT, MySqlParserBLOCK, MySqlParserBOOL, MySqlParserBOOLEAN, MySqlParserBTREE, MySqlParserCACHE, MySqlParserCASCADED, MySqlParserCHAIN, MySqlParserCHANGED, MySqlParserCHANNEL, MySqlParserCHECKSUM, MySqlParserPAGE_CHECKSUM, MySqlParserCIPHER, MySqlParserCLASS_ORIGIN, MySqlParserCLIENT, MySqlParserCLOSE, MySqlParserCLUSTERING, MySqlParserCOALESCE, MySqlParserCODE, MySqlParserCOLUMNS, MySqlParserCOLUMN_FORMAT, MySqlParserCOLUMN_NAME, MySqlParserCOMMENT, MySqlParserCOMMIT, MySqlParserCOMPACT, MySqlParserCOMPLETION, MySqlParserCOMPRESSED, MySqlParserCOMPRESSION, MySqlParserCONCURRENT, MySqlParserCONNECT, MySqlParserCONNECTION, MySqlParserCONSISTENT, MySqlParserCONSTRAINT_CATALOG, MySqlParserCONSTRAINT_SCHEMA, MySqlParserCONSTRAINT_NAME, MySqlParserCONTAINS, MySqlParserCONTEXT, MySqlParserCONTRIBUTORS, MySqlParserCOPY, MySqlParserCPU, MySqlParserCURSOR_NAME, MySqlParserDATA, MySqlParserDATAFILE, MySqlParserDEALLOCATE, MySqlParserDEFAULT_AUTH, MySqlParserDEFINER, MySqlParserDELAY_KEY_WRITE, MySqlParserDES_KEY_FILE, MySqlParserDIRECTORY, MySqlParserDISABLE, MySqlParserDISCARD, MySqlParserDISK, MySqlParserDO, MySqlParserDUMPFILE, MySqlParserDUPLICATE, MySqlParserDYNAMIC, MySqlParserENABLE, MySqlParserENCRYPTION, MySqlParserEND, MySqlParserENDS, MySqlParserENGINE, MySqlParserENGINES, MySqlParserERROR, MySqlParserERRORS, MySqlParserESCAPE, MySqlParserEVEN, MySqlParserEVENT, MySqlParserEVENTS, MySqlParserEVERY, MySqlParserEXCHANGE, MySqlParserEXCLUSIVE, MySqlParserEXPIRE, MySqlParserEXPORT, MySqlParserEXTENDED, MySqlParserEXTENT_SIZE, MySqlParserFAILED_LOGIN_ATTEMPTS, MySqlParserFAST, MySqlParserFAULTS, MySqlParserFIELDS, MySqlParserFILE_BLOCK_SIZE, MySqlParserFILTER, MySqlParserFIRST, MySqlParserFIXED, MySqlParserFLUSH, MySqlParserFOLLOWS, MySqlParserFOUND, MySqlParserFULL, MySqlParserFUNCTION, MySqlParserGENERAL, MySqlParserGLOBAL, MySqlParserGRANTS, MySqlParserGROUP_REPLICATION, MySqlParserHANDLER, MySqlParserHASH, MySqlParserHELP, MySqlParserHISTORY, MySqlParserHOST, MySqlParserHOSTS, MySqlParserIDENTIFIED, MySqlParserIGNORE_SERVER_IDS, MySqlParserIMPORT, MySqlParserINDEXES, MySqlParserINITIAL_SIZE, MySqlParserINPLACE, MySqlParserINSERT_METHOD, MySqlParserINSTALL, MySqlParserINSTANCE, MySqlParserINSTANT, MySqlParserINVISIBLE, MySqlParserINVOKER, MySqlParserIO, MySqlParserIO_THREAD, MySqlParserIPC, MySqlParserISOLATION, MySqlParserISSUER, MySqlParserJSON, MySqlParserKEY_BLOCK_SIZE, MySqlParserLANGUAGE, MySqlParserLAST, MySqlParserLEAVES, MySqlParserLESS, MySqlParserLEVEL, MySqlParserLIST, MySqlParserLOCAL, MySqlParserLOGFILE, MySqlParserLOGS, MySqlParserMASTER, MySqlParserMASTER_AUTO_POSITION, MySqlParserMASTER_CONNECT_RETRY, MySqlParserMASTER_DELAY, MySqlParserMASTER_HEARTBEAT_PERIOD, MySqlParserMASTER_HOST, MySqlParserMASTER_LOG_FILE, MySqlParserMASTER_LOG_POS, MySqlParserMASTER_PASSWORD, MySqlParserMASTER_PORT, MySqlParserMASTER_RETRY_COUNT, MySqlParserMASTER_SSL, MySqlParserMASTER_SSL_CA, MySqlParserMASTER_SSL_CAPATH, MySqlParserMASTER_SSL_CERT, MySqlParserMASTER_SSL_CIPHER, MySqlParserMASTER_SSL_CRL, MySqlParserMASTER_SSL_CRLPATH, MySqlParserMASTER_SSL_KEY, MySqlParserMASTER_TLS_VERSION, MySqlParserMASTER_USER, MySqlParserMAX_CONNECTIONS_PER_HOUR, MySqlParserMAX_QUERIES_PER_HOUR, MySqlParserMAX_ROWS, MySqlParserMAX_SIZE, MySqlParserMAX_UPDATES_PER_HOUR, MySqlParserMAX_USER_CONNECTIONS, MySqlParserMEDIUM, MySqlParserMEMBER, MySqlParserMERGE, MySqlParserMESSAGE_TEXT, MySqlParserMID, MySqlParserMIGRATE, MySqlParserMIN_ROWS, MySqlParserMODE, MySqlParserMODIFY, MySqlParserMUTEX, MySqlParserMYSQL, MySqlParserMYSQL_ERRNO, MySqlParserNAME, MySqlParserNAMES, MySqlParserNCHAR, MySqlParserNEVER, MySqlParserNEXT, MySqlParserNO, MySqlParserNOCOPY, MySqlParserNOWAIT, MySqlParserNODEGROUP, MySqlParserNONE, MySqlParserODBC, MySqlParserOFFLINE, MySqlParserOFFSET, MySqlParserOF, MySqlParserOJ, MySqlParserOLD_PASSWORD, MySqlParserONE, MySqlParserONLINE, MySqlParserONLY, MySqlParserOPEN, MySqlParserOPTIMIZER_COSTS, MySqlParserOPTIONS, MySqlParserOWNER, MySqlParserPACK_KEYS, MySqlParserPAGE, MySqlParserPARSER, MySqlParserPARTIAL, MySqlParserPARTITIONING, MySqlParserPARTITIONS, MySqlParserPASSWORD, MySqlParserPASSWORD_LOCK_TIME, MySqlParserPHASE, MySqlParserPLUGIN, MySqlParserPLUGIN_DIR, MySqlParserPLUGINS, MySqlParserPORT, MySqlParserPRECEDES, MySqlParserPREPARE, MySqlParserPRESERVE, MySqlParserPREV, MySqlParserPROCESSLIST, MySqlParserPROFILE, MySqlParserPROFILES, MySqlParserPROXY, MySqlParserQUERY, MySqlParserQUICK, MySqlParserREBUILD, MySqlParserRECOVER, MySqlParserRECURSIVE, MySqlParserREDO_BUFFER_SIZE, MySqlParserREDUNDANT, MySqlParserRELAY, MySqlParserRELAY_LOG_FILE, MySqlParserRELAY_LOG_POS, MySqlParserRELAYLOG, MySqlParserREMOVE, MySqlParserREORGANIZE, MySqlParserREPAIR, MySqlParserREPLICATE_DO_DB, MySqlParserREPLICATE_DO_TABLE, MySqlParserREPLICATE_IGNORE_DB, MySqlParserREPLICATE_IGNORE_TABLE, MySqlParserREPLICATE_REWRITE_DB, MySqlParserREPLICATE_WILD_DO_TABLE, MySqlParserREPLICATE_WILD_IGNORE_TABLE, MySqlParserREPLICATION, MySqlParserRESET, MySqlParserRESUME, MySqlParserRETURNED_SQLSTATE, MySqlParserRETURNING, MySqlParserRETURNS, MySqlParserREUSE, MySqlParserROLE, MySqlParserROLLBACK, MySqlParserROLLUP, MySqlParserROTATE, MySqlParserROW, MySqlParserROWS, MySqlParserROW_FORMAT, MySqlParserRTREE, MySqlParserSAVEPOINT, MySqlParserSCHEDULE, MySqlParserSECURITY, MySqlParserSERVER, MySqlParserSESSION, MySqlParserSHARE, MySqlParserSHARED, MySqlParserSIGNED, MySqlParserSIMPLE, MySqlParserSLAVE, MySqlParserSLOW, MySqlParserSNAPSHOT, MySqlParserSOCKET, MySqlParserSOME, MySqlParserSONAME, MySqlParserSOUNDS, MySqlParserSOURCE, MySqlParserSQL_AFTER_GTIDS, MySqlParserSQL_AFTER_MTS_GAPS, MySqlParserSQL_BEFORE_GTIDS, MySqlParserSQL_BUFFER_RESULT, MySqlParserSQL_CACHE, MySqlParserSQL_NO_CACHE, MySqlParserSQL_THREAD, MySqlParserSTART, MySqlParserSTARTS, MySqlParserSTATS_AUTO_RECALC, MySqlParserSTATS_PERSISTENT, MySqlParserSTATS_SAMPLE_PAGES, MySqlParserSTATUS, MySqlParserSTOP, MySqlParserSTORAGE, MySqlParserSTRING, MySqlParserSUBCLASS_ORIGIN, MySqlParserSUBJECT, MySqlParserSUBPARTITION, MySqlParserSUBPARTITIONS, MySqlParserSUSPEND, MySqlParserSWAPS, MySqlParserSWITCHES, MySqlParserTABLE_NAME, MySqlParserTABLESPACE, MySqlParserTABLE_TYPE, MySqlParserTEMPORARY, MySqlParserTEMPTABLE, MySqlParserTHAN, MySqlParserTRADITIONAL, MySqlParserTRANSACTION, MySqlParserTRANSACTIONAL, MySqlParserTRIGGERS, MySqlParserTRUNCATE, MySqlParserUNBOUNDED, MySqlParserUNDEFINED, MySqlParserUNDOFILE, MySqlParserUNDO_BUFFER_SIZE, MySqlParserUNINSTALL, MySqlParserUNKNOWN, MySqlParserUNTIL, MySqlParserUPGRADE, MySqlParserUSER, MySqlParserUSE_FRM, MySqlParserUSER_RESOURCES, MySqlParserVALIDATION, MySqlParserVALUE, MySqlParserVARIABLES, MySqlParserVIEW, MySqlParserVIRTUAL, MySqlParserVISIBLE, MySqlParserWAIT, MySqlParserWARNINGS, MySqlParserWITHOUT, MySqlParserWORK, MySqlParserWRAPPER, MySqlParserX509, MySqlParserXA, MySqlParserXML, MySqlParserYES, MySqlParserEUR, MySqlParserUSA, MySqlParserJIS, MySqlParserISO, MySqlParserINTERNAL, MySqlParserQUARTER, MySqlParserMONTH, MySqlParserDAY, MySqlParserHOUR, MySqlParserMINUTE, MySqlParserWEEK, MySqlParserSECOND, MySqlParserMICROSECOND, MySqlParserADMIN, MySqlParserAUDIT_ABORT_EXEMPT, MySqlParserAUDIT_ADMIN, MySqlParserAUTHENTICATION_POLICY_ADMIN, MySqlParserBACKUP_ADMIN, MySqlParserBINLOG_ADMIN, MySqlParserBINLOG_ENCRYPTION_ADMIN, MySqlParserCLONE_ADMIN, MySqlParserCONNECTION_ADMIN, MySqlParserENCRYPTION_KEY_ADMIN, MySqlParserEXECUTE, MySqlParserFILE, MySqlParserFIREWALL_ADMIN, MySqlParserFIREWALL_EXEMPT, MySqlParserFIREWALL_USER, MySqlParserGROUP_REPLICATION_ADMIN, MySqlParserINNODB_REDO_LOG_ARCHIVE, MySqlParserINVOKE, MySqlParserLAMBDA, MySqlParserNDB_STORED_USER, MySqlParserPASSWORDLESS_USER_ADMIN, MySqlParserPERSIST_RO_VARIABLES_ADMIN, MySqlParserPRIVILEGES, MySqlParserPROCESS, MySqlParserRELOAD, MySqlParserREPLICATION_APPLIER, MySqlParserREPLICATION_SLAVE_ADMIN, MySqlParserRESOURCE_GROUP_ADMIN, MySqlParserRESOURCE_GROUP_USER, MySqlParserROLE_ADMIN, MySqlParserROUTINE, MySqlParserS3, MySqlParserSESSION_VARIABLES_ADMIN, MySqlParserSET_USER_ID, MySqlParserSHOW_ROUTINE, MySqlParserSHUTDOWN, MySqlParserSUPER, MySqlParserSYSTEM_VARIABLES_ADMIN, MySqlParserTABLES, MySqlParserTABLE_ENCRYPTION_ADMIN, MySqlParserVERSION_TOKEN_ADMIN, MySqlParserXA_RECOVER_ADMIN, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserARCHIVE, MySqlParserBLACKHOLE, MySqlParserCSV, MySqlParserFEDERATED, MySqlParserINNODB, MySqlParserMEMORY, MySqlParserMRG_MYISAM, MySqlParserMYISAM, MySqlParserNDB, MySqlParserNDBCLUSTER, MySqlParserPERFORMANCE_SCHEMA, MySqlParserTOKUDB, MySqlParserREPEATABLE, MySqlParserCOMMITTED, MySqlParserUNCOMMITTED, MySqlParserSERIALIZABLE, MySqlParserGEOMETRYCOLLECTION, MySqlParserLINESTRING, MySqlParserMULTILINESTRING, MySqlParserMULTIPOINT, MySqlParserMULTIPOLYGON, MySqlParserPOINT, MySqlParserPOLYGON, MySqlParserABS, MySqlParserACOS, MySqlParserADDDATE, MySqlParserADDTIME, MySqlParserAES_DECRYPT, MySqlParserAES_ENCRYPT, MySqlParserAREA, MySqlParserASBINARY, MySqlParserASIN, MySqlParserASTEXT, MySqlParserASWKB, MySqlParserASWKT, MySqlParserASYMMETRIC_DECRYPT, MySqlParserASYMMETRIC_DERIVE, MySqlParserASYMMETRIC_ENCRYPT, MySqlParserASYMMETRIC_SIGN, MySqlParserASYMMETRIC_VERIFY, MySqlParserATAN, MySqlParserATAN2, MySqlParserBENCHMARK, MySqlParserBIN, MySqlParserBIT_COUNT, MySqlParserBIT_LENGTH, MySqlParserBUFFER, MySqlParserCATALOG_NAME, MySqlParserCEIL, MySqlParserCEILING, MySqlParserCENTROID, MySqlParserCHARACTER_LENGTH, MySqlParserCHARSET, MySqlParserCHAR_LENGTH, MySqlParserCOERCIBILITY, MySqlParserCOLLATION, MySqlParserCOMPRESS, MySqlParserCONCAT, MySqlParserCONCAT_WS, MySqlParserCONNECTION_ID, MySqlParserCONV, MySqlParserCONVERT_TZ, MySqlParserCOS, MySqlParserCOT, MySqlParserCRC32, MySqlParserCREATE_ASYMMETRIC_PRIV_KEY, MySqlParserCREATE_ASYMMETRIC_PUB_KEY, MySqlParserCREATE_DH_PARAMETERS, MySqlParserCREATE_DIGEST, MySqlParserCROSSES, MySqlParserDATEDIFF, MySqlParserDATE_FORMAT, MySqlParserDAYNAME, MySqlParserDAYOFMONTH, MySqlParserDAYOFWEEK, MySqlParserDAYOFYEAR, MySqlParserDECODE, MySqlParserDEGREES, MySqlParserDES_DECRYPT, MySqlParserDES_ENCRYPT, MySqlParserDIMENSION, MySqlParserDISJOINT, MySqlParserDISTANCE, MySqlParserELT, MySqlParserENCODE, MySqlParserENCRYPT, MySqlParserENDPOINT, MySqlParserENGINE_ATTRIBUTE, MySqlParserENVELOPE, MySqlParserEQUALS, MySqlParserEXP, MySqlParserEXPORT_SET, MySqlParserEXTERIORRING, MySqlParserEXTRACTVALUE, MySqlParserFIELD, MySqlParserFIND_IN_SET, MySqlParserFLOOR, MySqlParserFORMAT, MySqlParserFOUND_ROWS, MySqlParserFROM_BASE64, MySqlParserFROM_DAYS, MySqlParserFROM_UNIXTIME, MySqlParserGEOMCOLLFROMTEXT, MySqlParserGEOMCOLLFROMWKB, MySqlParserGEOMETRYCOLLECTIONFROMTEXT, MySqlParserGEOMETRYCOLLECTIONFROMWKB, MySqlParserGEOMETRYFROMTEXT, MySqlParserGEOMETRYFROMWKB, MySqlParserGEOMETRYN, MySqlParserGEOMETRYTYPE, MySqlParserGEOMFROMTEXT, MySqlParserGEOMFROMWKB, MySqlParserGET_FORMAT, MySqlParserGET_LOCK, MySqlParserGLENGTH, MySqlParserGREATEST, MySqlParserGTID_SUBSET, MySqlParserGTID_SUBTRACT, MySqlParserHEX, MySqlParserIFNULL, MySqlParserINET6_ATON, MySqlParserINET6_NTOA, MySqlParserINET_ATON, MySqlParserINET_NTOA, MySqlParserINSTR, MySqlParserINTERIORRINGN, MySqlParserINTERSECTS, MySqlParserISCLOSED, MySqlParserISEMPTY, MySqlParserISNULL, MySqlParserISSIMPLE, MySqlParserIS_FREE_LOCK, MySqlParserIS_IPV4, MySqlParserIS_IPV4_COMPAT, MySqlParserIS_IPV4_MAPPED, MySqlParserIS_IPV6, MySqlParserIS_USED_LOCK, MySqlParserLAST_INSERT_ID, MySqlParserLCASE, MySqlParserLEAST, MySqlParserLENGTH, MySqlParserLINEFROMTEXT, MySqlParserLINEFROMWKB, MySqlParserLINESTRINGFROMTEXT, MySqlParserLINESTRINGFROMWKB, MySqlParserLN, MySqlParserLOAD_FILE, MySqlParserLOCATE, MySqlParserLOG, MySqlParserLOG10, MySqlParserLOG2, MySqlParserLOWER, MySqlParserLPAD, MySqlParserLTRIM, MySqlParserMAKEDATE, MySqlParserMAKETIME, MySqlParserMAKE_SET, MySqlParserMASTER_POS_WAIT, MySqlParserMBRCONTAINS, MySqlParserMBRDISJOINT, MySqlParserMBREQUAL, MySqlParserMBRINTERSECTS, MySqlParserMBROVERLAPS, MySqlParserMBRTOUCHES, MySqlParserMBRWITHIN, MySqlParserMD5, MySqlParserMLINEFROMTEXT, MySqlParserMLINEFROMWKB, MySqlParserMONTHNAME, MySqlParserMPOINTFROMTEXT, MySqlParserMPOINTFROMWKB, MySqlParserMPOLYFROMTEXT, MySqlParserMPOLYFROMWKB, MySqlParserMULTILINESTRINGFROMTEXT, MySqlParserMULTILINESTRINGFROMWKB, MySqlParserMULTIPOINTFROMTEXT, MySqlParserMULTIPOINTFROMWKB, MySqlParserMULTIPOLYGONFROMTEXT, MySqlParserMULTIPOLYGONFROMWKB, MySqlParserNAME_CONST, MySqlParserNULLIF, MySqlParserNUMGEOMETRIES, MySqlParserNUMINTERIORRINGS, MySqlParserNUMPOINTS, MySqlParserOCT, MySqlParserOCTET_LENGTH, MySqlParserORD, MySqlParserOVERLAPS, MySqlParserPERIOD_ADD, MySqlParserPERIOD_DIFF, MySqlParserPI, MySqlParserPOINTFROMTEXT, MySqlParserPOINTFROMWKB, MySqlParserPOINTN, MySqlParserPOLYFROMTEXT, MySqlParserPOLYFROMWKB, MySqlParserPOLYGONFROMTEXT, MySqlParserPOLYGONFROMWKB, MySqlParserPOW, MySqlParserPOWER, MySqlParserQUOTE, MySqlParserRADIANS, MySqlParserRAND, MySqlParserRANDOM, MySqlParserRANDOM_BYTES, MySqlParserRELEASE_LOCK, MySqlParserREVERSE, MySqlParserROUND, MySqlParserROW_COUNT, MySqlParserRPAD, MySqlParserRTRIM, MySqlParserSEC_TO_TIME, MySqlParserSECONDARY_ENGINE_ATTRIBUTE, MySqlParserSESSION_USER, MySqlParserSHA, MySqlParserSHA1, MySqlParserSHA2, MySqlParserSCHEMA_NAME, MySqlParserSIGN, MySqlParserSIN, MySqlParserSLEEP, MySqlParserSOUNDEX, MySqlParserSQL_THREAD_WAIT_AFTER_GTIDS, MySqlParserSQRT, MySqlParserSRID, MySqlParserSTARTPOINT, MySqlParserSTRCMP, MySqlParserSTR_TO_DATE, MySqlParserST_AREA, MySqlParserST_ASBINARY, MySqlParserST_ASTEXT, MySqlParserST_ASWKB, MySqlParserST_ASWKT, MySqlParserST_BUFFER, MySqlParserST_CENTROID, MySqlParserST_CONTAINS, MySqlParserST_CROSSES, MySqlParserST_DIFFERENCE, MySqlParserST_DIMENSION, MySqlParserST_DISJOINT, MySqlParserST_DISTANCE, MySqlParserST_ENDPOINT, MySqlParserST_ENVELOPE, MySqlParserST_EQUALS, MySqlParserST_EXTERIORRING, MySqlParserST_GEOMCOLLFROMTEXT, MySqlParserST_GEOMCOLLFROMTXT, MySqlParserST_GEOMCOLLFROMWKB, MySqlParserST_GEOMETRYCOLLECTIONFROMTEXT, MySqlParserST_GEOMETRYCOLLECTIONFROMWKB, MySqlParserST_GEOMETRYFROMTEXT, MySqlParserST_GEOMETRYFROMWKB, MySqlParserST_GEOMETRYN, MySqlParserST_GEOMETRYTYPE, MySqlParserST_GEOMFROMTEXT, MySqlParserST_GEOMFROMWKB, MySqlParserST_INTERIORRINGN, MySqlParserST_INTERSECTION, MySqlParserST_INTERSECTS, MySqlParserST_ISCLOSED, MySqlParserST_ISEMPTY, MySqlParserST_ISSIMPLE, MySqlParserST_LINEFROMTEXT, MySqlParserST_LINEFROMWKB, MySqlParserST_LINESTRINGFROMTEXT, MySqlParserST_LINESTRINGFROMWKB, MySqlParserST_NUMGEOMETRIES, MySqlParserST_NUMINTERIORRING, MySqlParserST_NUMINTERIORRINGS, MySqlParserST_NUMPOINTS, MySqlParserST_OVERLAPS, MySqlParserST_POINTFROMTEXT, MySqlParserST_POINTFROMWKB, MySqlParserST_POINTN, MySqlParserST_POLYFROMTEXT, MySqlParserST_POLYFROMWKB, MySqlParserST_POLYGONFROMTEXT, MySqlParserST_POLYGONFROMWKB, MySqlParserST_SRID, MySqlParserST_STARTPOINT, MySqlParserST_SYMDIFFERENCE, MySqlParserST_TOUCHES, MySqlParserST_UNION, MySqlParserST_WITHIN, MySqlParserST_X, MySqlParserST_Y, MySqlParserSTRING_TO_VECTOR, MySqlParserSUBDATE, MySqlParserSUBSTRING_INDEX, MySqlParserSUBTIME, MySqlParserSYSTEM_USER, MySqlParserTAN, MySqlParserTIMEDIFF, MySqlParserTIMESTAMPADD, MySqlParserTIMESTAMPDIFF, MySqlParserTIME_FORMAT, MySqlParserTIME_TO_SEC, MySqlParserTOUCHES, MySqlParserTO_BASE64, MySqlParserTO_DAYS, MySqlParserTO_SECONDS, MySqlParserTP_CONNECTION_ADMIN, MySqlParserUCASE, MySqlParserUNCOMPRESS, MySqlParserUNCOMPRESSED_LENGTH, MySqlParserUNHEX, MySqlParserUNIX_TIMESTAMP, MySqlParserUPDATEXML, MySqlParserUPPER, MySqlParserUUID, MySqlParserUUID_SHORT, MySqlParserVALIDATE_PASSWORD_STRENGTH, MySqlParserVECTOR_DIM, MySqlParserVECTOR_TO_STRING, MySqlParserVERSION, MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS, MySqlParserWEEKDAY, MySqlParserWEEKOFYEAR, MySqlParserWEIGHT_STRING, MySqlParserWITHIN, MySqlParserYEARWEEK, MySqlParserY_FUNCTION, MySqlParserX_FUNCTION, MySqlParserMOD, MySqlParserCHARSET_REVERSE_QOUTE_STRING, MySqlParserSTRING_LITERAL, MySqlParserID: + localctx = NewHandlerConditionNameContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4925) + p.Uid() + } + + case MySqlParserSQLWARNING: + localctx = NewHandlerConditionWarningContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4926) + p.Match(MySqlParserSQLWARNING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserNOT: + localctx = NewHandlerConditionNotfoundContext(p, localctx) + p.EnterOuterAlt(localctx, 5) + { + p.SetState(4927) + p.Match(MySqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4928) + p.Match(MySqlParserFOUND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserSQLEXCEPTION: + localctx = NewHandlerConditionExceptionContext(p, localctx) + p.EnterOuterAlt(localctx, 6) + { + p.SetState(4929) + p.Match(MySqlParserSQLEXCEPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IProcedureSqlStatementContext is an interface to support dynamic dispatch. +type IProcedureSqlStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SEMI() antlr.TerminalNode + CompoundStatement() ICompoundStatementContext + SqlStatement() ISqlStatementContext + + // IsProcedureSqlStatementContext differentiates from other interfaces. + IsProcedureSqlStatementContext() +} + +type ProcedureSqlStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyProcedureSqlStatementContext() *ProcedureSqlStatementContext { + var p = new(ProcedureSqlStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_procedureSqlStatement + return p +} + +func InitEmptyProcedureSqlStatementContext(p *ProcedureSqlStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_procedureSqlStatement +} + +func (*ProcedureSqlStatementContext) IsProcedureSqlStatementContext() {} + +func NewProcedureSqlStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ProcedureSqlStatementContext { + var p = new(ProcedureSqlStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_procedureSqlStatement + + return p +} + +func (s *ProcedureSqlStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *ProcedureSqlStatementContext) SEMI() antlr.TerminalNode { + return s.GetToken(MySqlParserSEMI, 0) +} + +func (s *ProcedureSqlStatementContext) CompoundStatement() ICompoundStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICompoundStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICompoundStatementContext) +} + +func (s *ProcedureSqlStatementContext) SqlStatement() ISqlStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISqlStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISqlStatementContext) +} + +func (s *ProcedureSqlStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ProcedureSqlStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ProcedureSqlStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterProcedureSqlStatement(s) + } +} + +func (s *ProcedureSqlStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitProcedureSqlStatement(s) + } +} + +func (p *MySqlParser) ProcedureSqlStatement() (localctx IProcedureSqlStatementContext) { + localctx = NewProcedureSqlStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 420, MySqlParserRULE_procedureSqlStatement) + p.EnterOuterAlt(localctx, 1) + p.SetState(4934) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 716, p.GetParserRuleContext()) { + case 1: + { + p.SetState(4932) + p.CompoundStatement() + } + + case 2: + { + p.SetState(4933) + p.SqlStatement() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(4936) + p.Match(MySqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICaseAlternativeContext is an interface to support dynamic dispatch. +type ICaseAlternativeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WHEN() antlr.TerminalNode + THEN() antlr.TerminalNode + Constant() IConstantContext + Expression() IExpressionContext + AllProcedureSqlStatement() []IProcedureSqlStatementContext + ProcedureSqlStatement(i int) IProcedureSqlStatementContext + + // IsCaseAlternativeContext differentiates from other interfaces. + IsCaseAlternativeContext() +} + +type CaseAlternativeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCaseAlternativeContext() *CaseAlternativeContext { + var p = new(CaseAlternativeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_caseAlternative + return p +} + +func InitEmptyCaseAlternativeContext(p *CaseAlternativeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_caseAlternative +} + +func (*CaseAlternativeContext) IsCaseAlternativeContext() {} + +func NewCaseAlternativeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CaseAlternativeContext { + var p = new(CaseAlternativeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_caseAlternative + + return p +} + +func (s *CaseAlternativeContext) GetParser() antlr.Parser { return s.parser } + +func (s *CaseAlternativeContext) WHEN() antlr.TerminalNode { + return s.GetToken(MySqlParserWHEN, 0) +} + +func (s *CaseAlternativeContext) THEN() antlr.TerminalNode { + return s.GetToken(MySqlParserTHEN, 0) +} + +func (s *CaseAlternativeContext) Constant() IConstantContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstantContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstantContext) +} + +func (s *CaseAlternativeContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *CaseAlternativeContext) AllProcedureSqlStatement() []IProcedureSqlStatementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IProcedureSqlStatementContext); ok { + len++ + } + } + + tst := make([]IProcedureSqlStatementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IProcedureSqlStatementContext); ok { + tst[i] = t.(IProcedureSqlStatementContext) + i++ + } + } + + return tst +} + +func (s *CaseAlternativeContext) ProcedureSqlStatement(i int) IProcedureSqlStatementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProcedureSqlStatementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IProcedureSqlStatementContext) +} + +func (s *CaseAlternativeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CaseAlternativeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CaseAlternativeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCaseAlternative(s) + } +} + +func (s *CaseAlternativeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCaseAlternative(s) + } +} + +func (p *MySqlParser) CaseAlternative() (localctx ICaseAlternativeContext) { + localctx = NewCaseAlternativeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 422, MySqlParserRULE_caseAlternative) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4938) + p.Match(MySqlParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4941) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 717, p.GetParserRuleContext()) { + case 1: + { + p.SetState(4939) + p.Constant() + } + + case 2: + { + p.SetState(4940) + p.expression(0) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(4943) + p.Match(MySqlParserTHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4945) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(4944) + p.ProcedureSqlStatement() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(4947) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 718, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IElifAlternativeContext is an interface to support dynamic dispatch. +type IElifAlternativeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ELSEIF() antlr.TerminalNode + Expression() IExpressionContext + THEN() antlr.TerminalNode + AllProcedureSqlStatement() []IProcedureSqlStatementContext + ProcedureSqlStatement(i int) IProcedureSqlStatementContext + + // IsElifAlternativeContext differentiates from other interfaces. + IsElifAlternativeContext() +} + +type ElifAlternativeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyElifAlternativeContext() *ElifAlternativeContext { + var p = new(ElifAlternativeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_elifAlternative + return p +} + +func InitEmptyElifAlternativeContext(p *ElifAlternativeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_elifAlternative +} + +func (*ElifAlternativeContext) IsElifAlternativeContext() {} + +func NewElifAlternativeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ElifAlternativeContext { + var p = new(ElifAlternativeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_elifAlternative + + return p +} + +func (s *ElifAlternativeContext) GetParser() antlr.Parser { return s.parser } + +func (s *ElifAlternativeContext) ELSEIF() antlr.TerminalNode { + return s.GetToken(MySqlParserELSEIF, 0) +} + +func (s *ElifAlternativeContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *ElifAlternativeContext) THEN() antlr.TerminalNode { + return s.GetToken(MySqlParserTHEN, 0) +} + +func (s *ElifAlternativeContext) AllProcedureSqlStatement() []IProcedureSqlStatementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IProcedureSqlStatementContext); ok { + len++ + } + } + + tst := make([]IProcedureSqlStatementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IProcedureSqlStatementContext); ok { + tst[i] = t.(IProcedureSqlStatementContext) + i++ + } + } + + return tst +} + +func (s *ElifAlternativeContext) ProcedureSqlStatement(i int) IProcedureSqlStatementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProcedureSqlStatementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IProcedureSqlStatementContext) +} + +func (s *ElifAlternativeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ElifAlternativeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ElifAlternativeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterElifAlternative(s) + } +} + +func (s *ElifAlternativeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitElifAlternative(s) + } +} + +func (p *MySqlParser) ElifAlternative() (localctx IElifAlternativeContext) { + localctx = NewElifAlternativeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 424, MySqlParserRULE_elifAlternative) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4949) + p.Match(MySqlParserELSEIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4950) + p.expression(0) + } + { + p.SetState(4951) + p.Match(MySqlParserTHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4953) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(4952) + p.ProcedureSqlStatement() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(4955) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 719, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterUserContext is an interface to support dynamic dispatch. +type IAlterUserContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsAlterUserContext differentiates from other interfaces. + IsAlterUserContext() +} + +type AlterUserContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterUserContext() *AlterUserContext { + var p = new(AlterUserContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_alterUser + return p +} + +func InitEmptyAlterUserContext(p *AlterUserContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_alterUser +} + +func (*AlterUserContext) IsAlterUserContext() {} + +func NewAlterUserContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterUserContext { + var p = new(AlterUserContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_alterUser + + return p +} + +func (s *AlterUserContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterUserContext) CopyAll(ctx *AlterUserContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *AlterUserContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterUserContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type AlterUserMysqlV80Context struct { + AlterUserContext + tlsNone antlr.Token +} + +func NewAlterUserMysqlV80Context(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterUserMysqlV80Context { + var p = new(AlterUserMysqlV80Context) + + InitEmptyAlterUserContext(&p.AlterUserContext) + p.parser = parser + p.CopyAll(ctx.(*AlterUserContext)) + + return p +} + +func (s *AlterUserMysqlV80Context) GetTlsNone() antlr.Token { return s.tlsNone } + +func (s *AlterUserMysqlV80Context) SetTlsNone(v antlr.Token) { s.tlsNone = v } + +func (s *AlterUserMysqlV80Context) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterUserMysqlV80Context) ALTER() antlr.TerminalNode { + return s.GetToken(MySqlParserALTER, 0) +} + +func (s *AlterUserMysqlV80Context) USER() antlr.TerminalNode { + return s.GetToken(MySqlParserUSER, 0) +} + +func (s *AlterUserMysqlV80Context) AllUserAuthOption() []IUserAuthOptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUserAuthOptionContext); ok { + len++ + } + } + + tst := make([]IUserAuthOptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUserAuthOptionContext); ok { + tst[i] = t.(IUserAuthOptionContext) + i++ + } + } + + return tst +} + +func (s *AlterUserMysqlV80Context) UserAuthOption(i int) IUserAuthOptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserAuthOptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUserAuthOptionContext) +} + +func (s *AlterUserMysqlV80Context) IfExists() IIfExistsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfExistsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfExistsContext) +} + +func (s *AlterUserMysqlV80Context) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *AlterUserMysqlV80Context) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *AlterUserMysqlV80Context) REQUIRE() antlr.TerminalNode { + return s.GetToken(MySqlParserREQUIRE, 0) +} + +func (s *AlterUserMysqlV80Context) WITH() antlr.TerminalNode { + return s.GetToken(MySqlParserWITH, 0) +} + +func (s *AlterUserMysqlV80Context) AllUserPasswordOption() []IUserPasswordOptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUserPasswordOptionContext); ok { + len++ + } + } + + tst := make([]IUserPasswordOptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUserPasswordOptionContext); ok { + tst[i] = t.(IUserPasswordOptionContext) + i++ + } + } + + return tst +} + +func (s *AlterUserMysqlV80Context) UserPasswordOption(i int) IUserPasswordOptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserPasswordOptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUserPasswordOptionContext) +} + +func (s *AlterUserMysqlV80Context) AllUserLockOption() []IUserLockOptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUserLockOptionContext); ok { + len++ + } + } + + tst := make([]IUserLockOptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUserLockOptionContext); ok { + tst[i] = t.(IUserLockOptionContext) + i++ + } + } + + return tst +} + +func (s *AlterUserMysqlV80Context) UserLockOption(i int) IUserLockOptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserLockOptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUserLockOptionContext) +} + +func (s *AlterUserMysqlV80Context) COMMENT() antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMENT, 0) +} + +func (s *AlterUserMysqlV80Context) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *AlterUserMysqlV80Context) ATTRIBUTE() antlr.TerminalNode { + return s.GetToken(MySqlParserATTRIBUTE, 0) +} + +func (s *AlterUserMysqlV80Context) AllTlsOption() []ITlsOptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITlsOptionContext); ok { + len++ + } + } + + tst := make([]ITlsOptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITlsOptionContext); ok { + tst[i] = t.(ITlsOptionContext) + i++ + } + } + + return tst +} + +func (s *AlterUserMysqlV80Context) TlsOption(i int) ITlsOptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITlsOptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITlsOptionContext) +} + +func (s *AlterUserMysqlV80Context) NONE() antlr.TerminalNode { + return s.GetToken(MySqlParserNONE, 0) +} + +func (s *AlterUserMysqlV80Context) AllUserResourceOption() []IUserResourceOptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUserResourceOptionContext); ok { + len++ + } + } + + tst := make([]IUserResourceOptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUserResourceOptionContext); ok { + tst[i] = t.(IUserResourceOptionContext) + i++ + } + } + + return tst +} + +func (s *AlterUserMysqlV80Context) UserResourceOption(i int) IUserResourceOptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserResourceOptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUserResourceOptionContext) +} + +func (s *AlterUserMysqlV80Context) AllAND() []antlr.TerminalNode { + return s.GetTokens(MySqlParserAND) +} + +func (s *AlterUserMysqlV80Context) AND(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserAND, i) +} + +func (s *AlterUserMysqlV80Context) DEFAULT() antlr.TerminalNode { + return s.GetToken(MySqlParserDEFAULT, 0) +} + +func (s *AlterUserMysqlV80Context) ROLE() antlr.TerminalNode { + return s.GetToken(MySqlParserROLE, 0) +} + +func (s *AlterUserMysqlV80Context) RoleOption() IRoleOptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRoleOptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRoleOptionContext) +} + +func (s *AlterUserMysqlV80Context) UserName() IUserNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUserNameContext) +} + +func (s *AlterUserMysqlV80Context) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *AlterUserMysqlV80Context) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterUserMysqlV80(s) + } +} + +func (s *AlterUserMysqlV80Context) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterUserMysqlV80(s) + } +} + +type AlterUserMysqlV56Context struct { + AlterUserContext +} + +func NewAlterUserMysqlV56Context(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterUserMysqlV56Context { + var p = new(AlterUserMysqlV56Context) + + InitEmptyAlterUserContext(&p.AlterUserContext) + p.parser = parser + p.CopyAll(ctx.(*AlterUserContext)) + + return p +} + +func (s *AlterUserMysqlV56Context) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterUserMysqlV56Context) ALTER() antlr.TerminalNode { + return s.GetToken(MySqlParserALTER, 0) +} + +func (s *AlterUserMysqlV56Context) USER() antlr.TerminalNode { + return s.GetToken(MySqlParserUSER, 0) +} + +func (s *AlterUserMysqlV56Context) AllUserSpecification() []IUserSpecificationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUserSpecificationContext); ok { + len++ + } + } + + tst := make([]IUserSpecificationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUserSpecificationContext); ok { + tst[i] = t.(IUserSpecificationContext) + i++ + } + } + + return tst +} + +func (s *AlterUserMysqlV56Context) UserSpecification(i int) IUserSpecificationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserSpecificationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUserSpecificationContext) +} + +func (s *AlterUserMysqlV56Context) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *AlterUserMysqlV56Context) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *AlterUserMysqlV56Context) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAlterUserMysqlV56(s) + } +} + +func (s *AlterUserMysqlV56Context) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAlterUserMysqlV56(s) + } +} + +func (p *MySqlParser) AlterUser() (localctx IAlterUserContext) { + localctx = NewAlterUserContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 426, MySqlParserRULE_alterUser) + var _la int + + p.SetState(5030) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 734, p.GetParserRuleContext()) { + case 1: + localctx = NewAlterUserMysqlV56Context(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4957) + p.Match(MySqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4958) + p.Match(MySqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4959) + p.UserSpecification() + } + p.SetState(4964) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(4960) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4961) + p.UserSpecification() + } + + p.SetState(4966) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 2: + localctx = NewAlterUserMysqlV80Context(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4967) + p.Match(MySqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4968) + p.Match(MySqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4970) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserIF { + { + p.SetState(4969) + p.IfExists() + } + + } + { + p.SetState(4972) + p.UserAuthOption() + } + p.SetState(4977) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(4973) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4974) + p.UserAuthOption() + } + + p.SetState(4979) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(4994) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserREQUIRE { + { + p.SetState(4980) + p.Match(MySqlParserREQUIRE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4992) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserNONE: + { + p.SetState(4981) + + var _m = p.Match(MySqlParserNONE) + + localctx.(*AlterUserMysqlV80Context).tlsNone = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserSSL, MySqlParserCIPHER, MySqlParserISSUER, MySqlParserSUBJECT, MySqlParserX509: + { + p.SetState(4982) + p.TlsOption() + } + p.SetState(4989) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserAND || _la == MySqlParserSSL || _la == MySqlParserCIPHER || _la == MySqlParserISSUER || _la == MySqlParserSUBJECT || _la == MySqlParserX509 { + p.SetState(4984) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserAND { + { + p.SetState(4983) + p.Match(MySqlParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4986) + p.TlsOption() + } + + p.SetState(4991) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(5002) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 728, p.GetParserRuleContext()) == 1 { + { + p.SetState(4996) + p.Match(MySqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4998) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = ((int64((_la-499)) & ^0x3f) == 0 && ((int64(1)<<(_la-499))&51) != 0) { + { + p.SetState(4997) + p.UserResourceOption() + } + + p.SetState(5000) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5008) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserACCOUNT || _la == MySqlParserFAILED_LOGIN_ATTEMPTS || _la == MySqlParserPASSWORD || _la == MySqlParserPASSWORD_LOCK_TIME { + p.SetState(5006) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserFAILED_LOGIN_ATTEMPTS, MySqlParserPASSWORD, MySqlParserPASSWORD_LOCK_TIME: + { + p.SetState(5004) + p.UserPasswordOption() + } + + case MySqlParserACCOUNT: + { + p.SetState(5005) + p.UserLockOption() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(5010) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(5015) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case MySqlParserCOMMENT: + { + p.SetState(5011) + p.Match(MySqlParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5012) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserATTRIBUTE: + { + p.SetState(5013) + p.Match(MySqlParserATTRIBUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5014) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserEOF, MySqlParserALTER, MySqlParserANALYZE, MySqlParserCALL, MySqlParserCHANGE, MySqlParserCHECK, MySqlParserCREATE, MySqlParserDELETE, MySqlParserDESC, MySqlParserDESCRIBE, MySqlParserDROP, MySqlParserEXPLAIN, MySqlParserGET, MySqlParserGRANT, MySqlParserINSERT, MySqlParserKILL, MySqlParserLOAD, MySqlParserLOCK, MySqlParserOPTIMIZE, MySqlParserPURGE, MySqlParserRELEASE, MySqlParserRENAME, MySqlParserREPLACE, MySqlParserRESIGNAL, MySqlParserREVOKE, MySqlParserSELECT, MySqlParserSET, MySqlParserSHOW, MySqlParserSIGNAL, MySqlParserTABLE, MySqlParserUNLOCK, MySqlParserUPDATE, MySqlParserUSE, MySqlParserVALUES, MySqlParserWITH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserCACHE, MySqlParserCHECKSUM, MySqlParserCOMMIT, MySqlParserDEALLOCATE, MySqlParserDO, MySqlParserFLUSH, MySqlParserHANDLER, MySqlParserHELP, MySqlParserINSTALL, MySqlParserPREPARE, MySqlParserREPAIR, MySqlParserRESET, MySqlParserROLLBACK, MySqlParserSAVEPOINT, MySqlParserSTART, MySqlParserSTOP, MySqlParserTRUNCATE, MySqlParserUNINSTALL, MySqlParserXA, MySqlParserEXECUTE, MySqlParserSHUTDOWN, MySqlParserMINUS, MySqlParserLR_BRACKET, MySqlParserSEMI: + + default: + } + + case 3: + localctx = NewAlterUserMysqlV80Context(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5017) + p.Match(MySqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5018) + p.Match(MySqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5020) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 732, p.GetParserRuleContext()) == 1 { + { + p.SetState(5019) + p.IfExists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5024) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 733, p.GetParserRuleContext()) { + case 1: + { + p.SetState(5022) + p.UserName() + } + + case 2: + { + p.SetState(5023) + p.Uid() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(5026) + p.Match(MySqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5027) + p.Match(MySqlParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5028) + p.RoleOption() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreateUserContext is an interface to support dynamic dispatch. +type ICreateUserContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsCreateUserContext differentiates from other interfaces. + IsCreateUserContext() +} + +type CreateUserContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreateUserContext() *CreateUserContext { + var p = new(CreateUserContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_createUser + return p +} + +func InitEmptyCreateUserContext(p *CreateUserContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_createUser +} + +func (*CreateUserContext) IsCreateUserContext() {} + +func NewCreateUserContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateUserContext { + var p = new(CreateUserContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_createUser + + return p +} + +func (s *CreateUserContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateUserContext) CopyAll(ctx *CreateUserContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *CreateUserContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateUserContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type CreateUserMysqlV56Context struct { + CreateUserContext +} + +func NewCreateUserMysqlV56Context(parser antlr.Parser, ctx antlr.ParserRuleContext) *CreateUserMysqlV56Context { + var p = new(CreateUserMysqlV56Context) + + InitEmptyCreateUserContext(&p.CreateUserContext) + p.parser = parser + p.CopyAll(ctx.(*CreateUserContext)) + + return p +} + +func (s *CreateUserMysqlV56Context) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateUserMysqlV56Context) CREATE() antlr.TerminalNode { + return s.GetToken(MySqlParserCREATE, 0) +} + +func (s *CreateUserMysqlV56Context) USER() antlr.TerminalNode { + return s.GetToken(MySqlParserUSER, 0) +} + +func (s *CreateUserMysqlV56Context) AllUserAuthOption() []IUserAuthOptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUserAuthOptionContext); ok { + len++ + } + } + + tst := make([]IUserAuthOptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUserAuthOptionContext); ok { + tst[i] = t.(IUserAuthOptionContext) + i++ + } + } + + return tst +} + +func (s *CreateUserMysqlV56Context) UserAuthOption(i int) IUserAuthOptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserAuthOptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUserAuthOptionContext) +} + +func (s *CreateUserMysqlV56Context) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *CreateUserMysqlV56Context) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *CreateUserMysqlV56Context) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCreateUserMysqlV56(s) + } +} + +func (s *CreateUserMysqlV56Context) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCreateUserMysqlV56(s) + } +} + +type CreateUserMysqlV80Context struct { + CreateUserContext + tlsNone antlr.Token +} + +func NewCreateUserMysqlV80Context(parser antlr.Parser, ctx antlr.ParserRuleContext) *CreateUserMysqlV80Context { + var p = new(CreateUserMysqlV80Context) + + InitEmptyCreateUserContext(&p.CreateUserContext) + p.parser = parser + p.CopyAll(ctx.(*CreateUserContext)) + + return p +} + +func (s *CreateUserMysqlV80Context) GetTlsNone() antlr.Token { return s.tlsNone } + +func (s *CreateUserMysqlV80Context) SetTlsNone(v antlr.Token) { s.tlsNone = v } + +func (s *CreateUserMysqlV80Context) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateUserMysqlV80Context) CREATE() antlr.TerminalNode { + return s.GetToken(MySqlParserCREATE, 0) +} + +func (s *CreateUserMysqlV80Context) USER() antlr.TerminalNode { + return s.GetToken(MySqlParserUSER, 0) +} + +func (s *CreateUserMysqlV80Context) AllUserAuthOption() []IUserAuthOptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUserAuthOptionContext); ok { + len++ + } + } + + tst := make([]IUserAuthOptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUserAuthOptionContext); ok { + tst[i] = t.(IUserAuthOptionContext) + i++ + } + } + + return tst +} + +func (s *CreateUserMysqlV80Context) UserAuthOption(i int) IUserAuthOptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserAuthOptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUserAuthOptionContext) +} + +func (s *CreateUserMysqlV80Context) IfNotExists() IIfNotExistsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfNotExistsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfNotExistsContext) +} + +func (s *CreateUserMysqlV80Context) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *CreateUserMysqlV80Context) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *CreateUserMysqlV80Context) DEFAULT() antlr.TerminalNode { + return s.GetToken(MySqlParserDEFAULT, 0) +} + +func (s *CreateUserMysqlV80Context) ROLE() antlr.TerminalNode { + return s.GetToken(MySqlParserROLE, 0) +} + +func (s *CreateUserMysqlV80Context) RoleOption() IRoleOptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRoleOptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRoleOptionContext) +} + +func (s *CreateUserMysqlV80Context) REQUIRE() antlr.TerminalNode { + return s.GetToken(MySqlParserREQUIRE, 0) +} + +func (s *CreateUserMysqlV80Context) WITH() antlr.TerminalNode { + return s.GetToken(MySqlParserWITH, 0) +} + +func (s *CreateUserMysqlV80Context) AllUserPasswordOption() []IUserPasswordOptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUserPasswordOptionContext); ok { + len++ + } + } + + tst := make([]IUserPasswordOptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUserPasswordOptionContext); ok { + tst[i] = t.(IUserPasswordOptionContext) + i++ + } + } + + return tst +} + +func (s *CreateUserMysqlV80Context) UserPasswordOption(i int) IUserPasswordOptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserPasswordOptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUserPasswordOptionContext) +} + +func (s *CreateUserMysqlV80Context) AllUserLockOption() []IUserLockOptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUserLockOptionContext); ok { + len++ + } + } + + tst := make([]IUserLockOptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUserLockOptionContext); ok { + tst[i] = t.(IUserLockOptionContext) + i++ + } + } + + return tst +} + +func (s *CreateUserMysqlV80Context) UserLockOption(i int) IUserLockOptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserLockOptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUserLockOptionContext) +} + +func (s *CreateUserMysqlV80Context) COMMENT() antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMENT, 0) +} + +func (s *CreateUserMysqlV80Context) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *CreateUserMysqlV80Context) ATTRIBUTE() antlr.TerminalNode { + return s.GetToken(MySqlParserATTRIBUTE, 0) +} + +func (s *CreateUserMysqlV80Context) AllTlsOption() []ITlsOptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITlsOptionContext); ok { + len++ + } + } + + tst := make([]ITlsOptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITlsOptionContext); ok { + tst[i] = t.(ITlsOptionContext) + i++ + } + } + + return tst +} + +func (s *CreateUserMysqlV80Context) TlsOption(i int) ITlsOptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITlsOptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITlsOptionContext) +} + +func (s *CreateUserMysqlV80Context) NONE() antlr.TerminalNode { + return s.GetToken(MySqlParserNONE, 0) +} + +func (s *CreateUserMysqlV80Context) AllUserResourceOption() []IUserResourceOptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUserResourceOptionContext); ok { + len++ + } + } + + tst := make([]IUserResourceOptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUserResourceOptionContext); ok { + tst[i] = t.(IUserResourceOptionContext) + i++ + } + } + + return tst +} + +func (s *CreateUserMysqlV80Context) UserResourceOption(i int) IUserResourceOptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserResourceOptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUserResourceOptionContext) +} + +func (s *CreateUserMysqlV80Context) AllAND() []antlr.TerminalNode { + return s.GetTokens(MySqlParserAND) +} + +func (s *CreateUserMysqlV80Context) AND(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserAND, i) +} + +func (s *CreateUserMysqlV80Context) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCreateUserMysqlV80(s) + } +} + +func (s *CreateUserMysqlV80Context) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCreateUserMysqlV80(s) + } +} + +func (p *MySqlParser) CreateUser() (localctx ICreateUserContext) { + localctx = NewCreateUserContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 428, MySqlParserRULE_createUser) + var _la int + + p.SetState(5097) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 748, p.GetParserRuleContext()) { + case 1: + localctx = NewCreateUserMysqlV56Context(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5032) + p.Match(MySqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5033) + p.Match(MySqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5034) + p.UserAuthOption() + } + p.SetState(5039) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(5035) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5036) + p.UserAuthOption() + } + + p.SetState(5041) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 2: + localctx = NewCreateUserMysqlV80Context(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5042) + p.Match(MySqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5043) + p.Match(MySqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5045) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserIF { + { + p.SetState(5044) + p.IfNotExists() + } + + } + { + p.SetState(5047) + p.UserAuthOption() + } + p.SetState(5052) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(5048) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5049) + p.UserAuthOption() + } + + p.SetState(5054) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(5058) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserDEFAULT { + { + p.SetState(5055) + p.Match(MySqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5056) + p.Match(MySqlParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5057) + p.RoleOption() + } + + } + p.SetState(5074) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserREQUIRE { + { + p.SetState(5060) + p.Match(MySqlParserREQUIRE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5072) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserNONE: + { + p.SetState(5061) + + var _m = p.Match(MySqlParserNONE) + + localctx.(*CreateUserMysqlV80Context).tlsNone = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserSSL, MySqlParserCIPHER, MySqlParserISSUER, MySqlParserSUBJECT, MySqlParserX509: + { + p.SetState(5062) + p.TlsOption() + } + p.SetState(5069) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserAND || _la == MySqlParserSSL || _la == MySqlParserCIPHER || _la == MySqlParserISSUER || _la == MySqlParserSUBJECT || _la == MySqlParserX509 { + p.SetState(5064) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserAND { + { + p.SetState(5063) + p.Match(MySqlParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5066) + p.TlsOption() + } + + p.SetState(5071) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(5082) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 744, p.GetParserRuleContext()) == 1 { + { + p.SetState(5076) + p.Match(MySqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5078) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = ((int64((_la-499)) & ^0x3f) == 0 && ((int64(1)<<(_la-499))&51) != 0) { + { + p.SetState(5077) + p.UserResourceOption() + } + + p.SetState(5080) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5088) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserACCOUNT || _la == MySqlParserFAILED_LOGIN_ATTEMPTS || _la == MySqlParserPASSWORD || _la == MySqlParserPASSWORD_LOCK_TIME { + p.SetState(5086) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserFAILED_LOGIN_ATTEMPTS, MySqlParserPASSWORD, MySqlParserPASSWORD_LOCK_TIME: + { + p.SetState(5084) + p.UserPasswordOption() + } + + case MySqlParserACCOUNT: + { + p.SetState(5085) + p.UserLockOption() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(5090) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(5095) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case MySqlParserCOMMENT: + { + p.SetState(5091) + p.Match(MySqlParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5092) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserATTRIBUTE: + { + p.SetState(5093) + p.Match(MySqlParserATTRIBUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5094) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserEOF, MySqlParserALTER, MySqlParserANALYZE, MySqlParserCALL, MySqlParserCHANGE, MySqlParserCHECK, MySqlParserCREATE, MySqlParserDELETE, MySqlParserDESC, MySqlParserDESCRIBE, MySqlParserDROP, MySqlParserEXPLAIN, MySqlParserGET, MySqlParserGRANT, MySqlParserINSERT, MySqlParserKILL, MySqlParserLOAD, MySqlParserLOCK, MySqlParserOPTIMIZE, MySqlParserPURGE, MySqlParserRELEASE, MySqlParserRENAME, MySqlParserREPLACE, MySqlParserRESIGNAL, MySqlParserREVOKE, MySqlParserSELECT, MySqlParserSET, MySqlParserSHOW, MySqlParserSIGNAL, MySqlParserTABLE, MySqlParserUNLOCK, MySqlParserUPDATE, MySqlParserUSE, MySqlParserVALUES, MySqlParserWITH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserCACHE, MySqlParserCHECKSUM, MySqlParserCOMMIT, MySqlParserDEALLOCATE, MySqlParserDO, MySqlParserFLUSH, MySqlParserHANDLER, MySqlParserHELP, MySqlParserINSTALL, MySqlParserPREPARE, MySqlParserREPAIR, MySqlParserRESET, MySqlParserROLLBACK, MySqlParserSAVEPOINT, MySqlParserSTART, MySqlParserSTOP, MySqlParserTRUNCATE, MySqlParserUNINSTALL, MySqlParserXA, MySqlParserEXECUTE, MySqlParserSHUTDOWN, MySqlParserMINUS, MySqlParserLR_BRACKET, MySqlParserSEMI: + + default: + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDropUserContext is an interface to support dynamic dispatch. +type IDropUserContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + USER() antlr.TerminalNode + AllUserName() []IUserNameContext + UserName(i int) IUserNameContext + IfExists() IIfExistsContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsDropUserContext differentiates from other interfaces. + IsDropUserContext() +} + +type DropUserContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDropUserContext() *DropUserContext { + var p = new(DropUserContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_dropUser + return p +} + +func InitEmptyDropUserContext(p *DropUserContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_dropUser +} + +func (*DropUserContext) IsDropUserContext() {} + +func NewDropUserContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropUserContext { + var p = new(DropUserContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_dropUser + + return p +} + +func (s *DropUserContext) GetParser() antlr.Parser { return s.parser } + +func (s *DropUserContext) DROP() antlr.TerminalNode { + return s.GetToken(MySqlParserDROP, 0) +} + +func (s *DropUserContext) USER() antlr.TerminalNode { + return s.GetToken(MySqlParserUSER, 0) +} + +func (s *DropUserContext) AllUserName() []IUserNameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUserNameContext); ok { + len++ + } + } + + tst := make([]IUserNameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUserNameContext); ok { + tst[i] = t.(IUserNameContext) + i++ + } + } + + return tst +} + +func (s *DropUserContext) UserName(i int) IUserNameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserNameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUserNameContext) +} + +func (s *DropUserContext) IfExists() IIfExistsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfExistsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfExistsContext) +} + +func (s *DropUserContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *DropUserContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *DropUserContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropUserContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DropUserContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterDropUser(s) + } +} + +func (s *DropUserContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitDropUser(s) + } +} + +func (p *MySqlParser) DropUser() (localctx IDropUserContext) { + localctx = NewDropUserContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 430, MySqlParserRULE_dropUser) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5099) + p.Match(MySqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5100) + p.Match(MySqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5102) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserIF { + { + p.SetState(5101) + p.IfExists() + } + + } + { + p.SetState(5104) + p.UserName() + } + p.SetState(5109) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(5105) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5106) + p.UserName() + } + + p.SetState(5111) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGrantStatementContext is an interface to support dynamic dispatch. +type IGrantStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPrivilegeObject returns the privilegeObject token. + GetPrivilegeObject() antlr.Token + + // GetTlsNone returns the tlsNone token. + GetTlsNone() antlr.Token + + // SetPrivilegeObject sets the privilegeObject token. + SetPrivilegeObject(antlr.Token) + + // SetTlsNone sets the tlsNone token. + SetTlsNone(antlr.Token) + + // Getter signatures + AllGRANT() []antlr.TerminalNode + GRANT(i int) antlr.TerminalNode + AllPrivelegeClause() []IPrivelegeClauseContext + PrivelegeClause(i int) IPrivelegeClauseContext + ON() antlr.TerminalNode + PrivilegeLevel() IPrivilegeLevelContext + TO() antlr.TerminalNode + AllUserAuthOption() []IUserAuthOptionContext + UserAuthOption(i int) IUserAuthOptionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + REQUIRE() antlr.TerminalNode + AllWITH() []antlr.TerminalNode + WITH(i int) antlr.TerminalNode + AS() antlr.TerminalNode + AllUserName() []IUserNameContext + UserName(i int) IUserNameContext + ROLE() antlr.TerminalNode + RoleOption() IRoleOptionContext + TABLE() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + PROCEDURE() antlr.TerminalNode + AllTlsOption() []ITlsOptionContext + TlsOption(i int) ITlsOptionContext + NONE() antlr.TerminalNode + AllOPTION() []antlr.TerminalNode + OPTION(i int) antlr.TerminalNode + AllUserResourceOption() []IUserResourceOptionContext + UserResourceOption(i int) IUserResourceOptionContext + AllAND() []antlr.TerminalNode + AND(i int) antlr.TerminalNode + AllUid() []IUidContext + Uid(i int) IUidContext + ADMIN() antlr.TerminalNode + + // IsGrantStatementContext differentiates from other interfaces. + IsGrantStatementContext() +} + +type GrantStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + privilegeObject antlr.Token + tlsNone antlr.Token +} + +func NewEmptyGrantStatementContext() *GrantStatementContext { + var p = new(GrantStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_grantStatement + return p +} + +func InitEmptyGrantStatementContext(p *GrantStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_grantStatement +} + +func (*GrantStatementContext) IsGrantStatementContext() {} + +func NewGrantStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GrantStatementContext { + var p = new(GrantStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_grantStatement + + return p +} + +func (s *GrantStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *GrantStatementContext) GetPrivilegeObject() antlr.Token { return s.privilegeObject } + +func (s *GrantStatementContext) GetTlsNone() antlr.Token { return s.tlsNone } + +func (s *GrantStatementContext) SetPrivilegeObject(v antlr.Token) { s.privilegeObject = v } + +func (s *GrantStatementContext) SetTlsNone(v antlr.Token) { s.tlsNone = v } + +func (s *GrantStatementContext) AllGRANT() []antlr.TerminalNode { + return s.GetTokens(MySqlParserGRANT) +} + +func (s *GrantStatementContext) GRANT(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserGRANT, i) +} + +func (s *GrantStatementContext) AllPrivelegeClause() []IPrivelegeClauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPrivelegeClauseContext); ok { + len++ + } + } + + tst := make([]IPrivelegeClauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPrivelegeClauseContext); ok { + tst[i] = t.(IPrivelegeClauseContext) + i++ + } + } + + return tst +} + +func (s *GrantStatementContext) PrivelegeClause(i int) IPrivelegeClauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrivelegeClauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPrivelegeClauseContext) +} + +func (s *GrantStatementContext) ON() antlr.TerminalNode { + return s.GetToken(MySqlParserON, 0) +} + +func (s *GrantStatementContext) PrivilegeLevel() IPrivilegeLevelContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrivilegeLevelContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrivilegeLevelContext) +} + +func (s *GrantStatementContext) TO() antlr.TerminalNode { + return s.GetToken(MySqlParserTO, 0) +} + +func (s *GrantStatementContext) AllUserAuthOption() []IUserAuthOptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUserAuthOptionContext); ok { + len++ + } + } + + tst := make([]IUserAuthOptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUserAuthOptionContext); ok { + tst[i] = t.(IUserAuthOptionContext) + i++ + } + } + + return tst +} + +func (s *GrantStatementContext) UserAuthOption(i int) IUserAuthOptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserAuthOptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUserAuthOptionContext) +} + +func (s *GrantStatementContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *GrantStatementContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *GrantStatementContext) REQUIRE() antlr.TerminalNode { + return s.GetToken(MySqlParserREQUIRE, 0) +} + +func (s *GrantStatementContext) AllWITH() []antlr.TerminalNode { + return s.GetTokens(MySqlParserWITH) +} + +func (s *GrantStatementContext) WITH(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserWITH, i) +} + +func (s *GrantStatementContext) AS() antlr.TerminalNode { + return s.GetToken(MySqlParserAS, 0) +} + +func (s *GrantStatementContext) AllUserName() []IUserNameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUserNameContext); ok { + len++ + } + } + + tst := make([]IUserNameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUserNameContext); ok { + tst[i] = t.(IUserNameContext) + i++ + } + } + + return tst +} + +func (s *GrantStatementContext) UserName(i int) IUserNameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserNameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUserNameContext) +} + +func (s *GrantStatementContext) ROLE() antlr.TerminalNode { + return s.GetToken(MySqlParserROLE, 0) +} + +func (s *GrantStatementContext) RoleOption() IRoleOptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRoleOptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRoleOptionContext) +} + +func (s *GrantStatementContext) TABLE() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLE, 0) +} + +func (s *GrantStatementContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(MySqlParserFUNCTION, 0) +} + +func (s *GrantStatementContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(MySqlParserPROCEDURE, 0) +} + +func (s *GrantStatementContext) AllTlsOption() []ITlsOptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITlsOptionContext); ok { + len++ + } + } + + tst := make([]ITlsOptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITlsOptionContext); ok { + tst[i] = t.(ITlsOptionContext) + i++ + } + } + + return tst +} + +func (s *GrantStatementContext) TlsOption(i int) ITlsOptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITlsOptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITlsOptionContext) +} + +func (s *GrantStatementContext) NONE() antlr.TerminalNode { + return s.GetToken(MySqlParserNONE, 0) +} + +func (s *GrantStatementContext) AllOPTION() []antlr.TerminalNode { + return s.GetTokens(MySqlParserOPTION) +} + +func (s *GrantStatementContext) OPTION(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserOPTION, i) +} + +func (s *GrantStatementContext) AllUserResourceOption() []IUserResourceOptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUserResourceOptionContext); ok { + len++ + } + } + + tst := make([]IUserResourceOptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUserResourceOptionContext); ok { + tst[i] = t.(IUserResourceOptionContext) + i++ + } + } + + return tst +} + +func (s *GrantStatementContext) UserResourceOption(i int) IUserResourceOptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserResourceOptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUserResourceOptionContext) +} + +func (s *GrantStatementContext) AllAND() []antlr.TerminalNode { + return s.GetTokens(MySqlParserAND) +} + +func (s *GrantStatementContext) AND(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserAND, i) +} + +func (s *GrantStatementContext) AllUid() []IUidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUidContext); ok { + len++ + } + } + + tst := make([]IUidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUidContext); ok { + tst[i] = t.(IUidContext) + i++ + } + } + + return tst +} + +func (s *GrantStatementContext) Uid(i int) IUidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *GrantStatementContext) ADMIN() antlr.TerminalNode { + return s.GetToken(MySqlParserADMIN, 0) +} + +func (s *GrantStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *GrantStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *GrantStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterGrantStatement(s) + } +} + +func (s *GrantStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitGrantStatement(s) + } +} + +func (p *MySqlParser) GrantStatement() (localctx IGrantStatementContext) { + localctx = NewGrantStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 432, MySqlParserRULE_grantStatement) + var _la int + + var _alt int + + p.SetState(5205) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 769, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5112) + p.Match(MySqlParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5113) + p.PrivelegeClause() + } + p.SetState(5118) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(5114) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5115) + p.PrivelegeClause() + } + + p.SetState(5120) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5121) + p.Match(MySqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5123) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 752, p.GetParserRuleContext()) == 1 { + { + p.SetState(5122) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*GrantStatementContext).privilegeObject = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserPROCEDURE || _la == MySqlParserTABLE || _la == MySqlParserFUNCTION) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*GrantStatementContext).privilegeObject = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5125) + p.PrivilegeLevel() + } + { + p.SetState(5126) + p.Match(MySqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5127) + p.UserAuthOption() + } + p.SetState(5132) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(5128) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5129) + p.UserAuthOption() + } + + p.SetState(5134) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(5149) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserREQUIRE { + { + p.SetState(5135) + p.Match(MySqlParserREQUIRE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5147) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserNONE: + { + p.SetState(5136) + + var _m = p.Match(MySqlParserNONE) + + localctx.(*GrantStatementContext).tlsNone = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserSSL, MySqlParserCIPHER, MySqlParserISSUER, MySqlParserSUBJECT, MySqlParserX509: + { + p.SetState(5137) + p.TlsOption() + } + p.SetState(5144) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserAND || _la == MySqlParserSSL || _la == MySqlParserCIPHER || _la == MySqlParserISSUER || _la == MySqlParserSUBJECT || _la == MySqlParserX509 { + p.SetState(5139) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserAND { + { + p.SetState(5138) + p.Match(MySqlParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5141) + p.TlsOption() + } + + p.SetState(5146) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(5160) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 760, p.GetParserRuleContext()) == 1 { + { + p.SetState(5151) + p.Match(MySqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5157) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 759, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(5155) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserGRANT: + { + p.SetState(5152) + p.Match(MySqlParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5153) + p.Match(MySqlParserOPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserMAX_CONNECTIONS_PER_HOUR, MySqlParserMAX_QUERIES_PER_HOUR, MySqlParserMAX_UPDATES_PER_HOUR, MySqlParserMAX_USER_CONNECTIONS: + { + p.SetState(5154) + p.UserResourceOption() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(5159) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 759, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5168) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserAS { + { + p.SetState(5162) + p.Match(MySqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5163) + p.UserName() + } + { + p.SetState(5164) + p.Match(MySqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5165) + p.Match(MySqlParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5166) + p.RoleOption() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5170) + p.Match(MySqlParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5173) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 762, p.GetParserRuleContext()) { + case 1: + { + p.SetState(5171) + p.UserName() + } + + case 2: + { + p.SetState(5172) + p.Uid() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(5182) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(5175) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5178) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 763, p.GetParserRuleContext()) { + case 1: + { + p.SetState(5176) + p.UserName() + } + + case 2: + { + p.SetState(5177) + p.Uid() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(5184) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5185) + p.Match(MySqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5188) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 765, p.GetParserRuleContext()) { + case 1: + { + p.SetState(5186) + p.UserName() + } + + case 2: + { + p.SetState(5187) + p.Uid() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(5197) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(5190) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5193) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 766, p.GetParserRuleContext()) { + case 1: + { + p.SetState(5191) + p.UserName() + } + + case 2: + { + p.SetState(5192) + p.Uid() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(5199) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(5203) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 768, p.GetParserRuleContext()) == 1 { + { + p.SetState(5200) + p.Match(MySqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5201) + p.Match(MySqlParserADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5202) + p.Match(MySqlParserOPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRoleOptionContext is an interface to support dynamic dispatch. +type IRoleOptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DEFAULT() antlr.TerminalNode + NONE() antlr.TerminalNode + ALL() antlr.TerminalNode + EXCEPT() antlr.TerminalNode + AllUserName() []IUserNameContext + UserName(i int) IUserNameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsRoleOptionContext differentiates from other interfaces. + IsRoleOptionContext() +} + +type RoleOptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRoleOptionContext() *RoleOptionContext { + var p = new(RoleOptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_roleOption + return p +} + +func InitEmptyRoleOptionContext(p *RoleOptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_roleOption +} + +func (*RoleOptionContext) IsRoleOptionContext() {} + +func NewRoleOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RoleOptionContext { + var p = new(RoleOptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_roleOption + + return p +} + +func (s *RoleOptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *RoleOptionContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(MySqlParserDEFAULT, 0) +} + +func (s *RoleOptionContext) NONE() antlr.TerminalNode { + return s.GetToken(MySqlParserNONE, 0) +} + +func (s *RoleOptionContext) ALL() antlr.TerminalNode { + return s.GetToken(MySqlParserALL, 0) +} + +func (s *RoleOptionContext) EXCEPT() antlr.TerminalNode { + return s.GetToken(MySqlParserEXCEPT, 0) +} + +func (s *RoleOptionContext) AllUserName() []IUserNameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUserNameContext); ok { + len++ + } + } + + tst := make([]IUserNameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUserNameContext); ok { + tst[i] = t.(IUserNameContext) + i++ + } + } + + return tst +} + +func (s *RoleOptionContext) UserName(i int) IUserNameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserNameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUserNameContext) +} + +func (s *RoleOptionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *RoleOptionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *RoleOptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RoleOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RoleOptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterRoleOption(s) + } +} + +func (s *RoleOptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitRoleOption(s) + } +} + +func (p *MySqlParser) RoleOption() (localctx IRoleOptionContext) { + localctx = NewRoleOptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 434, MySqlParserRULE_roleOption) + var _la int + + p.SetState(5229) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 773, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5207) + p.Match(MySqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5208) + p.Match(MySqlParserNONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5209) + p.Match(MySqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5219) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEXCEPT { + { + p.SetState(5210) + p.Match(MySqlParserEXCEPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5211) + p.UserName() + } + p.SetState(5216) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(5212) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5213) + p.UserName() + } + + p.SetState(5218) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5221) + p.UserName() + } + p.SetState(5226) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(5222) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5223) + p.UserName() + } + + p.SetState(5228) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGrantProxyContext is an interface to support dynamic dispatch. +type IGrantProxyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetFromFirst returns the fromFirst rule contexts. + GetFromFirst() IUserNameContext + + // GetToFirst returns the toFirst rule contexts. + GetToFirst() IUserNameContext + + // Get_userName returns the _userName rule contexts. + Get_userName() IUserNameContext + + // SetFromFirst sets the fromFirst rule contexts. + SetFromFirst(IUserNameContext) + + // SetToFirst sets the toFirst rule contexts. + SetToFirst(IUserNameContext) + + // Set_userName sets the _userName rule contexts. + Set_userName(IUserNameContext) + + // GetToOther returns the toOther rule context list. + GetToOther() []IUserNameContext + + // SetToOther sets the toOther rule context list. + SetToOther([]IUserNameContext) + + // Getter signatures + AllGRANT() []antlr.TerminalNode + GRANT(i int) antlr.TerminalNode + PROXY() antlr.TerminalNode + ON() antlr.TerminalNode + TO() antlr.TerminalNode + AllUserName() []IUserNameContext + UserName(i int) IUserNameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + WITH() antlr.TerminalNode + OPTION() antlr.TerminalNode + + // IsGrantProxyContext differentiates from other interfaces. + IsGrantProxyContext() +} + +type GrantProxyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + fromFirst IUserNameContext + toFirst IUserNameContext + _userName IUserNameContext + toOther []IUserNameContext +} + +func NewEmptyGrantProxyContext() *GrantProxyContext { + var p = new(GrantProxyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_grantProxy + return p +} + +func InitEmptyGrantProxyContext(p *GrantProxyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_grantProxy +} + +func (*GrantProxyContext) IsGrantProxyContext() {} + +func NewGrantProxyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GrantProxyContext { + var p = new(GrantProxyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_grantProxy + + return p +} + +func (s *GrantProxyContext) GetParser() antlr.Parser { return s.parser } + +func (s *GrantProxyContext) GetFromFirst() IUserNameContext { return s.fromFirst } + +func (s *GrantProxyContext) GetToFirst() IUserNameContext { return s.toFirst } + +func (s *GrantProxyContext) Get_userName() IUserNameContext { return s._userName } + +func (s *GrantProxyContext) SetFromFirst(v IUserNameContext) { s.fromFirst = v } + +func (s *GrantProxyContext) SetToFirst(v IUserNameContext) { s.toFirst = v } + +func (s *GrantProxyContext) Set_userName(v IUserNameContext) { s._userName = v } + +func (s *GrantProxyContext) GetToOther() []IUserNameContext { return s.toOther } + +func (s *GrantProxyContext) SetToOther(v []IUserNameContext) { s.toOther = v } + +func (s *GrantProxyContext) AllGRANT() []antlr.TerminalNode { + return s.GetTokens(MySqlParserGRANT) +} + +func (s *GrantProxyContext) GRANT(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserGRANT, i) +} + +func (s *GrantProxyContext) PROXY() antlr.TerminalNode { + return s.GetToken(MySqlParserPROXY, 0) +} + +func (s *GrantProxyContext) ON() antlr.TerminalNode { + return s.GetToken(MySqlParserON, 0) +} + +func (s *GrantProxyContext) TO() antlr.TerminalNode { + return s.GetToken(MySqlParserTO, 0) +} + +func (s *GrantProxyContext) AllUserName() []IUserNameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUserNameContext); ok { + len++ + } + } + + tst := make([]IUserNameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUserNameContext); ok { + tst[i] = t.(IUserNameContext) + i++ + } + } + + return tst +} + +func (s *GrantProxyContext) UserName(i int) IUserNameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserNameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUserNameContext) +} + +func (s *GrantProxyContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *GrantProxyContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *GrantProxyContext) WITH() antlr.TerminalNode { + return s.GetToken(MySqlParserWITH, 0) +} + +func (s *GrantProxyContext) OPTION() antlr.TerminalNode { + return s.GetToken(MySqlParserOPTION, 0) +} + +func (s *GrantProxyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *GrantProxyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *GrantProxyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterGrantProxy(s) + } +} + +func (s *GrantProxyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitGrantProxy(s) + } +} + +func (p *MySqlParser) GrantProxy() (localctx IGrantProxyContext) { + localctx = NewGrantProxyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 436, MySqlParserRULE_grantProxy) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5231) + p.Match(MySqlParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5232) + p.Match(MySqlParserPROXY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5233) + p.Match(MySqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5234) + + var _x = p.UserName() + + localctx.(*GrantProxyContext).fromFirst = _x + } + { + p.SetState(5235) + p.Match(MySqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5236) + + var _x = p.UserName() + + localctx.(*GrantProxyContext).toFirst = _x + } + p.SetState(5241) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(5237) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5238) + + var _x = p.UserName() + + localctx.(*GrantProxyContext)._userName = _x + } + localctx.(*GrantProxyContext).toOther = append(localctx.(*GrantProxyContext).toOther, localctx.(*GrantProxyContext)._userName) + + p.SetState(5243) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(5247) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 775, p.GetParserRuleContext()) == 1 { + { + p.SetState(5244) + p.Match(MySqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5245) + p.Match(MySqlParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5246) + p.Match(MySqlParserOPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRenameUserContext is an interface to support dynamic dispatch. +type IRenameUserContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RENAME() antlr.TerminalNode + USER() antlr.TerminalNode + AllRenameUserClause() []IRenameUserClauseContext + RenameUserClause(i int) IRenameUserClauseContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsRenameUserContext differentiates from other interfaces. + IsRenameUserContext() +} + +type RenameUserContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRenameUserContext() *RenameUserContext { + var p = new(RenameUserContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_renameUser + return p +} + +func InitEmptyRenameUserContext(p *RenameUserContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_renameUser +} + +func (*RenameUserContext) IsRenameUserContext() {} + +func NewRenameUserContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RenameUserContext { + var p = new(RenameUserContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_renameUser + + return p +} + +func (s *RenameUserContext) GetParser() antlr.Parser { return s.parser } + +func (s *RenameUserContext) RENAME() antlr.TerminalNode { + return s.GetToken(MySqlParserRENAME, 0) +} + +func (s *RenameUserContext) USER() antlr.TerminalNode { + return s.GetToken(MySqlParserUSER, 0) +} + +func (s *RenameUserContext) AllRenameUserClause() []IRenameUserClauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRenameUserClauseContext); ok { + len++ + } + } + + tst := make([]IRenameUserClauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRenameUserClauseContext); ok { + tst[i] = t.(IRenameUserClauseContext) + i++ + } + } + + return tst +} + +func (s *RenameUserContext) RenameUserClause(i int) IRenameUserClauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRenameUserClauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRenameUserClauseContext) +} + +func (s *RenameUserContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *RenameUserContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *RenameUserContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RenameUserContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RenameUserContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterRenameUser(s) + } +} + +func (s *RenameUserContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitRenameUser(s) + } +} + +func (p *MySqlParser) RenameUser() (localctx IRenameUserContext) { + localctx = NewRenameUserContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 438, MySqlParserRULE_renameUser) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5249) + p.Match(MySqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5250) + p.Match(MySqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5251) + p.RenameUserClause() + } + p.SetState(5256) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(5252) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5253) + p.RenameUserClause() + } + + p.SetState(5258) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRevokeStatementContext is an interface to support dynamic dispatch. +type IRevokeStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsRevokeStatementContext differentiates from other interfaces. + IsRevokeStatementContext() +} + +type RevokeStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRevokeStatementContext() *RevokeStatementContext { + var p = new(RevokeStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_revokeStatement + return p +} + +func InitEmptyRevokeStatementContext(p *RevokeStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_revokeStatement +} + +func (*RevokeStatementContext) IsRevokeStatementContext() {} + +func NewRevokeStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RevokeStatementContext { + var p = new(RevokeStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_revokeStatement + + return p +} + +func (s *RevokeStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *RevokeStatementContext) CopyAll(ctx *RevokeStatementContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *RevokeStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RevokeStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type DetailRevokeContext struct { + RevokeStatementContext + privilegeObject antlr.Token +} + +func NewDetailRevokeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DetailRevokeContext { + var p = new(DetailRevokeContext) + + InitEmptyRevokeStatementContext(&p.RevokeStatementContext) + p.parser = parser + p.CopyAll(ctx.(*RevokeStatementContext)) + + return p +} + +func (s *DetailRevokeContext) GetPrivilegeObject() antlr.Token { return s.privilegeObject } + +func (s *DetailRevokeContext) SetPrivilegeObject(v antlr.Token) { s.privilegeObject = v } + +func (s *DetailRevokeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DetailRevokeContext) REVOKE() antlr.TerminalNode { + return s.GetToken(MySqlParserREVOKE, 0) +} + +func (s *DetailRevokeContext) ON() antlr.TerminalNode { + return s.GetToken(MySqlParserON, 0) +} + +func (s *DetailRevokeContext) PrivilegeLevel() IPrivilegeLevelContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrivilegeLevelContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrivilegeLevelContext) +} + +func (s *DetailRevokeContext) FROM() antlr.TerminalNode { + return s.GetToken(MySqlParserFROM, 0) +} + +func (s *DetailRevokeContext) AllUserName() []IUserNameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUserNameContext); ok { + len++ + } + } + + tst := make([]IUserNameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUserNameContext); ok { + tst[i] = t.(IUserNameContext) + i++ + } + } + + return tst +} + +func (s *DetailRevokeContext) UserName(i int) IUserNameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserNameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUserNameContext) +} + +func (s *DetailRevokeContext) AllPrivelegeClause() []IPrivelegeClauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPrivelegeClauseContext); ok { + len++ + } + } + + tst := make([]IPrivelegeClauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPrivelegeClauseContext); ok { + tst[i] = t.(IPrivelegeClauseContext) + i++ + } + } + + return tst +} + +func (s *DetailRevokeContext) PrivelegeClause(i int) IPrivelegeClauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrivelegeClauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPrivelegeClauseContext) +} + +func (s *DetailRevokeContext) AllUid() []IUidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUidContext); ok { + len++ + } + } + + tst := make([]IUidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUidContext); ok { + tst[i] = t.(IUidContext) + i++ + } + } + + return tst +} + +func (s *DetailRevokeContext) Uid(i int) IUidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *DetailRevokeContext) IfExists() IIfExistsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfExistsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfExistsContext) +} + +func (s *DetailRevokeContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *DetailRevokeContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *DetailRevokeContext) IGNORE() antlr.TerminalNode { + return s.GetToken(MySqlParserIGNORE, 0) +} + +func (s *DetailRevokeContext) UNKNOWN() antlr.TerminalNode { + return s.GetToken(MySqlParserUNKNOWN, 0) +} + +func (s *DetailRevokeContext) USER() antlr.TerminalNode { + return s.GetToken(MySqlParserUSER, 0) +} + +func (s *DetailRevokeContext) TABLE() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLE, 0) +} + +func (s *DetailRevokeContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(MySqlParserFUNCTION, 0) +} + +func (s *DetailRevokeContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(MySqlParserPROCEDURE, 0) +} + +func (s *DetailRevokeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterDetailRevoke(s) + } +} + +func (s *DetailRevokeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitDetailRevoke(s) + } +} + +type RoleRevokeContext struct { + RevokeStatementContext +} + +func NewRoleRevokeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RoleRevokeContext { + var p = new(RoleRevokeContext) + + InitEmptyRevokeStatementContext(&p.RevokeStatementContext) + p.parser = parser + p.CopyAll(ctx.(*RevokeStatementContext)) + + return p +} + +func (s *RoleRevokeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RoleRevokeContext) REVOKE() antlr.TerminalNode { + return s.GetToken(MySqlParserREVOKE, 0) +} + +func (s *RoleRevokeContext) FROM() antlr.TerminalNode { + return s.GetToken(MySqlParserFROM, 0) +} + +func (s *RoleRevokeContext) AllUserName() []IUserNameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUserNameContext); ok { + len++ + } + } + + tst := make([]IUserNameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUserNameContext); ok { + tst[i] = t.(IUserNameContext) + i++ + } + } + + return tst +} + +func (s *RoleRevokeContext) UserName(i int) IUserNameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserNameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUserNameContext) +} + +func (s *RoleRevokeContext) AllUid() []IUidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUidContext); ok { + len++ + } + } + + tst := make([]IUidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUidContext); ok { + tst[i] = t.(IUidContext) + i++ + } + } + + return tst +} + +func (s *RoleRevokeContext) Uid(i int) IUidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *RoleRevokeContext) IfExists() IIfExistsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfExistsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfExistsContext) +} + +func (s *RoleRevokeContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *RoleRevokeContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *RoleRevokeContext) IGNORE() antlr.TerminalNode { + return s.GetToken(MySqlParserIGNORE, 0) +} + +func (s *RoleRevokeContext) UNKNOWN() antlr.TerminalNode { + return s.GetToken(MySqlParserUNKNOWN, 0) +} + +func (s *RoleRevokeContext) USER() antlr.TerminalNode { + return s.GetToken(MySqlParserUSER, 0) +} + +func (s *RoleRevokeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterRoleRevoke(s) + } +} + +func (s *RoleRevokeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitRoleRevoke(s) + } +} + +type ShortRevokeContext struct { + RevokeStatementContext +} + +func NewShortRevokeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShortRevokeContext { + var p = new(ShortRevokeContext) + + InitEmptyRevokeStatementContext(&p.RevokeStatementContext) + p.parser = parser + p.CopyAll(ctx.(*RevokeStatementContext)) + + return p +} + +func (s *ShortRevokeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShortRevokeContext) REVOKE() antlr.TerminalNode { + return s.GetToken(MySqlParserREVOKE, 0) +} + +func (s *ShortRevokeContext) ALL() antlr.TerminalNode { + return s.GetToken(MySqlParserALL, 0) +} + +func (s *ShortRevokeContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *ShortRevokeContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *ShortRevokeContext) GRANT() antlr.TerminalNode { + return s.GetToken(MySqlParserGRANT, 0) +} + +func (s *ShortRevokeContext) OPTION() antlr.TerminalNode { + return s.GetToken(MySqlParserOPTION, 0) +} + +func (s *ShortRevokeContext) FROM() antlr.TerminalNode { + return s.GetToken(MySqlParserFROM, 0) +} + +func (s *ShortRevokeContext) AllUserName() []IUserNameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUserNameContext); ok { + len++ + } + } + + tst := make([]IUserNameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUserNameContext); ok { + tst[i] = t.(IUserNameContext) + i++ + } + } + + return tst +} + +func (s *ShortRevokeContext) UserName(i int) IUserNameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserNameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUserNameContext) +} + +func (s *ShortRevokeContext) IfExists() IIfExistsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfExistsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfExistsContext) +} + +func (s *ShortRevokeContext) PRIVILEGES() antlr.TerminalNode { + return s.GetToken(MySqlParserPRIVILEGES, 0) +} + +func (s *ShortRevokeContext) IGNORE() antlr.TerminalNode { + return s.GetToken(MySqlParserIGNORE, 0) +} + +func (s *ShortRevokeContext) UNKNOWN() antlr.TerminalNode { + return s.GetToken(MySqlParserUNKNOWN, 0) +} + +func (s *ShortRevokeContext) USER() antlr.TerminalNode { + return s.GetToken(MySqlParserUSER, 0) +} + +func (s *ShortRevokeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterShortRevoke(s) + } +} + +func (s *ShortRevokeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitShortRevoke(s) + } +} + +func (p *MySqlParser) RevokeStatement() (localctx IRevokeStatementContext) { + localctx = NewRevokeStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 440, MySqlParserRULE_revokeStatement) + var _la int + + p.SetState(5357) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 796, p.GetParserRuleContext()) { + case 1: + localctx = NewDetailRevokeContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5259) + p.Match(MySqlParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5261) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 777, p.GetParserRuleContext()) == 1 { + { + p.SetState(5260) + p.IfExists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5265) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 778, p.GetParserRuleContext()) { + case 1: + { + p.SetState(5263) + p.PrivelegeClause() + } + + case 2: + { + p.SetState(5264) + p.Uid() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(5272) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756891332513122304) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055071174737) != 0) || ((int64((_la-140)) & ^0x3f) == 0 && ((int64(1)<<(_la-140))&1342440707) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-34354363873) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-2199023255553) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-5764611921080745985) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-8796126576641) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-32651097298436097) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-18014398517872129) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-137438953601) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-44473063500156929) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-129) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-12289) != 0) || ((int64((_la-857)) & ^0x3f) == 0 && ((int64(1)<<(_la-857))&-1) != 0) || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-1) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&-1) != 0) || ((int64((_la-1049)) & ^0x3f) == 0 && ((int64(1)<<(_la-1049))&-1) != 0) || ((int64((_la-1128)) & ^0x3f) == 0 && ((int64(1)<<(_la-1128))&8627687425) != 0) { + p.SetState(5270) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserCOMMA: + { + p.SetState(5267) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5268) + p.PrivelegeClause() + } + + case MySqlParserARRAY, MySqlParserATTRIBUTE, MySqlParserBUCKETS, MySqlParserCONDITION, MySqlParserCURRENT, MySqlParserCURRENT_USER, MySqlParserDATABASE, MySqlParserDEFAULT, MySqlParserDIAGNOSTICS, MySqlParserEMPTY, MySqlParserENFORCED, MySqlParserEXCEPT, MySqlParserGROUP, MySqlParserIF, MySqlParserIGNORED, MySqlParserINSERT, MySqlParserLATERAL, MySqlParserLEFT, MySqlParserNUMBER, MySqlParserOPTIONAL, MySqlParserORDER, MySqlParserPRIMARY, MySqlParserREPEAT, MySqlParserREPLACE, MySqlParserRIGHT, MySqlParserSCHEMA, MySqlParserSKIP_QUERY_REWRITE, MySqlParserSTACKED, MySqlParserSTATEMENT, MySqlParserDATE, MySqlParserTIME, MySqlParserTIMESTAMP, MySqlParserDATETIME, MySqlParserYEAR, MySqlParserBINARY, MySqlParserTEXT, MySqlParserENUM, MySqlParserSERIAL, MySqlParserJSON_ARRAY, MySqlParserJSON_ARRAYAGG, MySqlParserJSON_ARRAY_APPEND, MySqlParserJSON_ARRAY_INSERT, MySqlParserJSON_CONTAINS, MySqlParserJSON_CONTAINS_PATH, MySqlParserJSON_DEPTH, MySqlParserJSON_EXTRACT, MySqlParserJSON_INSERT, MySqlParserJSON_KEYS, MySqlParserJSON_LENGTH, MySqlParserJSON_MERGE, MySqlParserJSON_MERGE_PATCH, MySqlParserJSON_MERGE_PRESERVE, MySqlParserJSON_OBJECT, MySqlParserJSON_OBJECTAGG, MySqlParserJSON_OVERLAPS, MySqlParserJSON_PRETTY, MySqlParserJSON_QUOTE, MySqlParserJSON_REMOVE, MySqlParserJSON_REPLACE, MySqlParserJSON_SCHEMA_VALID, MySqlParserJSON_SCHEMA_VALIDATION_REPORT, MySqlParserJSON_SEARCH, MySqlParserJSON_SET, MySqlParserJSON_STORAGE_FREE, MySqlParserJSON_STORAGE_SIZE, MySqlParserJSON_TABLE, MySqlParserJSON_TYPE, MySqlParserJSON_UNQUOTE, MySqlParserJSON_VALID, MySqlParserJSON_VALUE, MySqlParserNESTED, MySqlParserORDINALITY, MySqlParserPATH, MySqlParserAVG, MySqlParserBIT_AND, MySqlParserBIT_OR, MySqlParserBIT_XOR, MySqlParserCOUNT, MySqlParserCUME_DIST, MySqlParserDENSE_RANK, MySqlParserFIRST_VALUE, MySqlParserGROUP_CONCAT, MySqlParserLAG, MySqlParserLAST_VALUE, MySqlParserLEAD, MySqlParserMAX, MySqlParserMIN, MySqlParserNTILE, MySqlParserNTH_VALUE, MySqlParserPERCENT_RANK, MySqlParserRANK, MySqlParserROW_NUMBER, MySqlParserSTD, MySqlParserSTDDEV, MySqlParserSTDDEV_POP, MySqlParserSTDDEV_SAMP, MySqlParserSUM, MySqlParserVAR_POP, MySqlParserVAR_SAMP, MySqlParserVARIANCE, MySqlParserCURRENT_DATE, MySqlParserCURRENT_TIME, MySqlParserCURRENT_TIMESTAMP, MySqlParserLOCALTIME, MySqlParserCURDATE, MySqlParserCURTIME, MySqlParserDATE_ADD, MySqlParserDATE_SUB, MySqlParserLOCALTIMESTAMP, MySqlParserNOW, MySqlParserPOSITION, MySqlParserSUBSTR, MySqlParserSUBSTRING, MySqlParserSYSDATE, MySqlParserTRIM, MySqlParserUTC_DATE, MySqlParserUTC_TIME, MySqlParserUTC_TIMESTAMP, MySqlParserACCOUNT, MySqlParserACTION, MySqlParserAFTER, MySqlParserAGGREGATE, MySqlParserALGORITHM, MySqlParserANY, MySqlParserAT, MySqlParserAUTHORS, MySqlParserAUTOCOMMIT, MySqlParserAUTOEXTEND_SIZE, MySqlParserAUTO_INCREMENT, MySqlParserAVG_ROW_LENGTH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserBIT, MySqlParserBLOCK, MySqlParserBOOL, MySqlParserBOOLEAN, MySqlParserBTREE, MySqlParserCACHE, MySqlParserCASCADED, MySqlParserCHAIN, MySqlParserCHANGED, MySqlParserCHANNEL, MySqlParserCHECKSUM, MySqlParserPAGE_CHECKSUM, MySqlParserCIPHER, MySqlParserCLASS_ORIGIN, MySqlParserCLIENT, MySqlParserCLOSE, MySqlParserCLUSTERING, MySqlParserCOALESCE, MySqlParserCODE, MySqlParserCOLUMNS, MySqlParserCOLUMN_FORMAT, MySqlParserCOLUMN_NAME, MySqlParserCOMMENT, MySqlParserCOMMIT, MySqlParserCOMPACT, MySqlParserCOMPLETION, MySqlParserCOMPRESSED, MySqlParserCOMPRESSION, MySqlParserCONCURRENT, MySqlParserCONNECT, MySqlParserCONNECTION, MySqlParserCONSISTENT, MySqlParserCONSTRAINT_CATALOG, MySqlParserCONSTRAINT_SCHEMA, MySqlParserCONSTRAINT_NAME, MySqlParserCONTAINS, MySqlParserCONTEXT, MySqlParserCONTRIBUTORS, MySqlParserCOPY, MySqlParserCPU, MySqlParserCURSOR_NAME, MySqlParserDATA, MySqlParserDATAFILE, MySqlParserDEALLOCATE, MySqlParserDEFAULT_AUTH, MySqlParserDEFINER, MySqlParserDELAY_KEY_WRITE, MySqlParserDES_KEY_FILE, MySqlParserDIRECTORY, MySqlParserDISABLE, MySqlParserDISCARD, MySqlParserDISK, MySqlParserDO, MySqlParserDUMPFILE, MySqlParserDUPLICATE, MySqlParserDYNAMIC, MySqlParserENABLE, MySqlParserENCRYPTION, MySqlParserEND, MySqlParserENDS, MySqlParserENGINE, MySqlParserENGINES, MySqlParserERROR, MySqlParserERRORS, MySqlParserESCAPE, MySqlParserEVEN, MySqlParserEVENT, MySqlParserEVENTS, MySqlParserEVERY, MySqlParserEXCHANGE, MySqlParserEXCLUSIVE, MySqlParserEXPIRE, MySqlParserEXPORT, MySqlParserEXTENDED, MySqlParserEXTENT_SIZE, MySqlParserFAILED_LOGIN_ATTEMPTS, MySqlParserFAST, MySqlParserFAULTS, MySqlParserFIELDS, MySqlParserFILE_BLOCK_SIZE, MySqlParserFILTER, MySqlParserFIRST, MySqlParserFIXED, MySqlParserFLUSH, MySqlParserFOLLOWS, MySqlParserFOUND, MySqlParserFULL, MySqlParserFUNCTION, MySqlParserGENERAL, MySqlParserGLOBAL, MySqlParserGRANTS, MySqlParserGROUP_REPLICATION, MySqlParserHANDLER, MySqlParserHASH, MySqlParserHELP, MySqlParserHISTORY, MySqlParserHOST, MySqlParserHOSTS, MySqlParserIDENTIFIED, MySqlParserIGNORE_SERVER_IDS, MySqlParserIMPORT, MySqlParserINDEXES, MySqlParserINITIAL_SIZE, MySqlParserINPLACE, MySqlParserINSERT_METHOD, MySqlParserINSTALL, MySqlParserINSTANCE, MySqlParserINSTANT, MySqlParserINVISIBLE, MySqlParserINVOKER, MySqlParserIO, MySqlParserIO_THREAD, MySqlParserIPC, MySqlParserISOLATION, MySqlParserISSUER, MySqlParserJSON, MySqlParserKEY_BLOCK_SIZE, MySqlParserLANGUAGE, MySqlParserLAST, MySqlParserLEAVES, MySqlParserLESS, MySqlParserLEVEL, MySqlParserLIST, MySqlParserLOCAL, MySqlParserLOGFILE, MySqlParserLOGS, MySqlParserMASTER, MySqlParserMASTER_AUTO_POSITION, MySqlParserMASTER_CONNECT_RETRY, MySqlParserMASTER_DELAY, MySqlParserMASTER_HEARTBEAT_PERIOD, MySqlParserMASTER_HOST, MySqlParserMASTER_LOG_FILE, MySqlParserMASTER_LOG_POS, MySqlParserMASTER_PASSWORD, MySqlParserMASTER_PORT, MySqlParserMASTER_RETRY_COUNT, MySqlParserMASTER_SSL, MySqlParserMASTER_SSL_CA, MySqlParserMASTER_SSL_CAPATH, MySqlParserMASTER_SSL_CERT, MySqlParserMASTER_SSL_CIPHER, MySqlParserMASTER_SSL_CRL, MySqlParserMASTER_SSL_CRLPATH, MySqlParserMASTER_SSL_KEY, MySqlParserMASTER_TLS_VERSION, MySqlParserMASTER_USER, MySqlParserMAX_CONNECTIONS_PER_HOUR, MySqlParserMAX_QUERIES_PER_HOUR, MySqlParserMAX_ROWS, MySqlParserMAX_SIZE, MySqlParserMAX_UPDATES_PER_HOUR, MySqlParserMAX_USER_CONNECTIONS, MySqlParserMEDIUM, MySqlParserMEMBER, MySqlParserMERGE, MySqlParserMESSAGE_TEXT, MySqlParserMID, MySqlParserMIGRATE, MySqlParserMIN_ROWS, MySqlParserMODE, MySqlParserMODIFY, MySqlParserMUTEX, MySqlParserMYSQL, MySqlParserMYSQL_ERRNO, MySqlParserNAME, MySqlParserNAMES, MySqlParserNCHAR, MySqlParserNEVER, MySqlParserNEXT, MySqlParserNO, MySqlParserNOCOPY, MySqlParserNOWAIT, MySqlParserNODEGROUP, MySqlParserNONE, MySqlParserODBC, MySqlParserOFFLINE, MySqlParserOFFSET, MySqlParserOF, MySqlParserOJ, MySqlParserOLD_PASSWORD, MySqlParserONE, MySqlParserONLINE, MySqlParserONLY, MySqlParserOPEN, MySqlParserOPTIMIZER_COSTS, MySqlParserOPTIONS, MySqlParserOWNER, MySqlParserPACK_KEYS, MySqlParserPAGE, MySqlParserPARSER, MySqlParserPARTIAL, MySqlParserPARTITIONING, MySqlParserPARTITIONS, MySqlParserPASSWORD, MySqlParserPASSWORD_LOCK_TIME, MySqlParserPHASE, MySqlParserPLUGIN, MySqlParserPLUGIN_DIR, MySqlParserPLUGINS, MySqlParserPORT, MySqlParserPRECEDES, MySqlParserPREPARE, MySqlParserPRESERVE, MySqlParserPREV, MySqlParserPROCESSLIST, MySqlParserPROFILE, MySqlParserPROFILES, MySqlParserPROXY, MySqlParserQUERY, MySqlParserQUICK, MySqlParserREBUILD, MySqlParserRECOVER, MySqlParserRECURSIVE, MySqlParserREDO_BUFFER_SIZE, MySqlParserREDUNDANT, MySqlParserRELAY, MySqlParserRELAY_LOG_FILE, MySqlParserRELAY_LOG_POS, MySqlParserRELAYLOG, MySqlParserREMOVE, MySqlParserREORGANIZE, MySqlParserREPAIR, MySqlParserREPLICATE_DO_DB, MySqlParserREPLICATE_DO_TABLE, MySqlParserREPLICATE_IGNORE_DB, MySqlParserREPLICATE_IGNORE_TABLE, MySqlParserREPLICATE_REWRITE_DB, MySqlParserREPLICATE_WILD_DO_TABLE, MySqlParserREPLICATE_WILD_IGNORE_TABLE, MySqlParserREPLICATION, MySqlParserRESET, MySqlParserRESUME, MySqlParserRETURNED_SQLSTATE, MySqlParserRETURNING, MySqlParserRETURNS, MySqlParserREUSE, MySqlParserROLE, MySqlParserROLLBACK, MySqlParserROLLUP, MySqlParserROTATE, MySqlParserROW, MySqlParserROWS, MySqlParserROW_FORMAT, MySqlParserRTREE, MySqlParserSAVEPOINT, MySqlParserSCHEDULE, MySqlParserSECURITY, MySqlParserSERVER, MySqlParserSESSION, MySqlParserSHARE, MySqlParserSHARED, MySqlParserSIGNED, MySqlParserSIMPLE, MySqlParserSLAVE, MySqlParserSLOW, MySqlParserSNAPSHOT, MySqlParserSOCKET, MySqlParserSOME, MySqlParserSONAME, MySqlParserSOUNDS, MySqlParserSOURCE, MySqlParserSQL_AFTER_GTIDS, MySqlParserSQL_AFTER_MTS_GAPS, MySqlParserSQL_BEFORE_GTIDS, MySqlParserSQL_BUFFER_RESULT, MySqlParserSQL_CACHE, MySqlParserSQL_NO_CACHE, MySqlParserSQL_THREAD, MySqlParserSTART, MySqlParserSTARTS, MySqlParserSTATS_AUTO_RECALC, MySqlParserSTATS_PERSISTENT, MySqlParserSTATS_SAMPLE_PAGES, MySqlParserSTATUS, MySqlParserSTOP, MySqlParserSTORAGE, MySqlParserSTRING, MySqlParserSUBCLASS_ORIGIN, MySqlParserSUBJECT, MySqlParserSUBPARTITION, MySqlParserSUBPARTITIONS, MySqlParserSUSPEND, MySqlParserSWAPS, MySqlParserSWITCHES, MySqlParserTABLE_NAME, MySqlParserTABLESPACE, MySqlParserTABLE_TYPE, MySqlParserTEMPORARY, MySqlParserTEMPTABLE, MySqlParserTHAN, MySqlParserTRADITIONAL, MySqlParserTRANSACTION, MySqlParserTRANSACTIONAL, MySqlParserTRIGGERS, MySqlParserTRUNCATE, MySqlParserUNBOUNDED, MySqlParserUNDEFINED, MySqlParserUNDOFILE, MySqlParserUNDO_BUFFER_SIZE, MySqlParserUNINSTALL, MySqlParserUNKNOWN, MySqlParserUNTIL, MySqlParserUPGRADE, MySqlParserUSER, MySqlParserUSE_FRM, MySqlParserUSER_RESOURCES, MySqlParserVALIDATION, MySqlParserVALUE, MySqlParserVARIABLES, MySqlParserVIEW, MySqlParserVIRTUAL, MySqlParserVISIBLE, MySqlParserWAIT, MySqlParserWARNINGS, MySqlParserWITHOUT, MySqlParserWORK, MySqlParserWRAPPER, MySqlParserX509, MySqlParserXA, MySqlParserXML, MySqlParserYES, MySqlParserEUR, MySqlParserUSA, MySqlParserJIS, MySqlParserISO, MySqlParserINTERNAL, MySqlParserQUARTER, MySqlParserMONTH, MySqlParserDAY, MySqlParserHOUR, MySqlParserMINUTE, MySqlParserWEEK, MySqlParserSECOND, MySqlParserMICROSECOND, MySqlParserADMIN, MySqlParserAUDIT_ABORT_EXEMPT, MySqlParserAUDIT_ADMIN, MySqlParserAUTHENTICATION_POLICY_ADMIN, MySqlParserBACKUP_ADMIN, MySqlParserBINLOG_ADMIN, MySqlParserBINLOG_ENCRYPTION_ADMIN, MySqlParserCLONE_ADMIN, MySqlParserCONNECTION_ADMIN, MySqlParserENCRYPTION_KEY_ADMIN, MySqlParserEXECUTE, MySqlParserFILE, MySqlParserFIREWALL_ADMIN, MySqlParserFIREWALL_EXEMPT, MySqlParserFIREWALL_USER, MySqlParserGROUP_REPLICATION_ADMIN, MySqlParserINNODB_REDO_LOG_ARCHIVE, MySqlParserINVOKE, MySqlParserLAMBDA, MySqlParserNDB_STORED_USER, MySqlParserPASSWORDLESS_USER_ADMIN, MySqlParserPERSIST_RO_VARIABLES_ADMIN, MySqlParserPRIVILEGES, MySqlParserPROCESS, MySqlParserRELOAD, MySqlParserREPLICATION_APPLIER, MySqlParserREPLICATION_SLAVE_ADMIN, MySqlParserRESOURCE_GROUP_ADMIN, MySqlParserRESOURCE_GROUP_USER, MySqlParserROLE_ADMIN, MySqlParserROUTINE, MySqlParserS3, MySqlParserSESSION_VARIABLES_ADMIN, MySqlParserSET_USER_ID, MySqlParserSHOW_ROUTINE, MySqlParserSHUTDOWN, MySqlParserSUPER, MySqlParserSYSTEM_VARIABLES_ADMIN, MySqlParserTABLES, MySqlParserTABLE_ENCRYPTION_ADMIN, MySqlParserVERSION_TOKEN_ADMIN, MySqlParserXA_RECOVER_ADMIN, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserARCHIVE, MySqlParserBLACKHOLE, MySqlParserCSV, MySqlParserFEDERATED, MySqlParserINNODB, MySqlParserMEMORY, MySqlParserMRG_MYISAM, MySqlParserMYISAM, MySqlParserNDB, MySqlParserNDBCLUSTER, MySqlParserPERFORMANCE_SCHEMA, MySqlParserTOKUDB, MySqlParserREPEATABLE, MySqlParserCOMMITTED, MySqlParserUNCOMMITTED, MySqlParserSERIALIZABLE, MySqlParserGEOMETRYCOLLECTION, MySqlParserLINESTRING, MySqlParserMULTILINESTRING, MySqlParserMULTIPOINT, MySqlParserMULTIPOLYGON, MySqlParserPOINT, MySqlParserPOLYGON, MySqlParserABS, MySqlParserACOS, MySqlParserADDDATE, MySqlParserADDTIME, MySqlParserAES_DECRYPT, MySqlParserAES_ENCRYPT, MySqlParserAREA, MySqlParserASBINARY, MySqlParserASIN, MySqlParserASTEXT, MySqlParserASWKB, MySqlParserASWKT, MySqlParserASYMMETRIC_DECRYPT, MySqlParserASYMMETRIC_DERIVE, MySqlParserASYMMETRIC_ENCRYPT, MySqlParserASYMMETRIC_SIGN, MySqlParserASYMMETRIC_VERIFY, MySqlParserATAN, MySqlParserATAN2, MySqlParserBENCHMARK, MySqlParserBIN, MySqlParserBIT_COUNT, MySqlParserBIT_LENGTH, MySqlParserBUFFER, MySqlParserCATALOG_NAME, MySqlParserCEIL, MySqlParserCEILING, MySqlParserCENTROID, MySqlParserCHARACTER_LENGTH, MySqlParserCHARSET, MySqlParserCHAR_LENGTH, MySqlParserCOERCIBILITY, MySqlParserCOLLATION, MySqlParserCOMPRESS, MySqlParserCONCAT, MySqlParserCONCAT_WS, MySqlParserCONNECTION_ID, MySqlParserCONV, MySqlParserCONVERT_TZ, MySqlParserCOS, MySqlParserCOT, MySqlParserCRC32, MySqlParserCREATE_ASYMMETRIC_PRIV_KEY, MySqlParserCREATE_ASYMMETRIC_PUB_KEY, MySqlParserCREATE_DH_PARAMETERS, MySqlParserCREATE_DIGEST, MySqlParserCROSSES, MySqlParserDATEDIFF, MySqlParserDATE_FORMAT, MySqlParserDAYNAME, MySqlParserDAYOFMONTH, MySqlParserDAYOFWEEK, MySqlParserDAYOFYEAR, MySqlParserDECODE, MySqlParserDEGREES, MySqlParserDES_DECRYPT, MySqlParserDES_ENCRYPT, MySqlParserDIMENSION, MySqlParserDISJOINT, MySqlParserDISTANCE, MySqlParserELT, MySqlParserENCODE, MySqlParserENCRYPT, MySqlParserENDPOINT, MySqlParserENGINE_ATTRIBUTE, MySqlParserENVELOPE, MySqlParserEQUALS, MySqlParserEXP, MySqlParserEXPORT_SET, MySqlParserEXTERIORRING, MySqlParserEXTRACTVALUE, MySqlParserFIELD, MySqlParserFIND_IN_SET, MySqlParserFLOOR, MySqlParserFORMAT, MySqlParserFOUND_ROWS, MySqlParserFROM_BASE64, MySqlParserFROM_DAYS, MySqlParserFROM_UNIXTIME, MySqlParserGEOMCOLLFROMTEXT, MySqlParserGEOMCOLLFROMWKB, MySqlParserGEOMETRYCOLLECTIONFROMTEXT, MySqlParserGEOMETRYCOLLECTIONFROMWKB, MySqlParserGEOMETRYFROMTEXT, MySqlParserGEOMETRYFROMWKB, MySqlParserGEOMETRYN, MySqlParserGEOMETRYTYPE, MySqlParserGEOMFROMTEXT, MySqlParserGEOMFROMWKB, MySqlParserGET_FORMAT, MySqlParserGET_LOCK, MySqlParserGLENGTH, MySqlParserGREATEST, MySqlParserGTID_SUBSET, MySqlParserGTID_SUBTRACT, MySqlParserHEX, MySqlParserIFNULL, MySqlParserINET6_ATON, MySqlParserINET6_NTOA, MySqlParserINET_ATON, MySqlParserINET_NTOA, MySqlParserINSTR, MySqlParserINTERIORRINGN, MySqlParserINTERSECTS, MySqlParserISCLOSED, MySqlParserISEMPTY, MySqlParserISNULL, MySqlParserISSIMPLE, MySqlParserIS_FREE_LOCK, MySqlParserIS_IPV4, MySqlParserIS_IPV4_COMPAT, MySqlParserIS_IPV4_MAPPED, MySqlParserIS_IPV6, MySqlParserIS_USED_LOCK, MySqlParserLAST_INSERT_ID, MySqlParserLCASE, MySqlParserLEAST, MySqlParserLENGTH, MySqlParserLINEFROMTEXT, MySqlParserLINEFROMWKB, MySqlParserLINESTRINGFROMTEXT, MySqlParserLINESTRINGFROMWKB, MySqlParserLN, MySqlParserLOAD_FILE, MySqlParserLOCATE, MySqlParserLOG, MySqlParserLOG10, MySqlParserLOG2, MySqlParserLOWER, MySqlParserLPAD, MySqlParserLTRIM, MySqlParserMAKEDATE, MySqlParserMAKETIME, MySqlParserMAKE_SET, MySqlParserMASTER_POS_WAIT, MySqlParserMBRCONTAINS, MySqlParserMBRDISJOINT, MySqlParserMBREQUAL, MySqlParserMBRINTERSECTS, MySqlParserMBROVERLAPS, MySqlParserMBRTOUCHES, MySqlParserMBRWITHIN, MySqlParserMD5, MySqlParserMLINEFROMTEXT, MySqlParserMLINEFROMWKB, MySqlParserMONTHNAME, MySqlParserMPOINTFROMTEXT, MySqlParserMPOINTFROMWKB, MySqlParserMPOLYFROMTEXT, MySqlParserMPOLYFROMWKB, MySqlParserMULTILINESTRINGFROMTEXT, MySqlParserMULTILINESTRINGFROMWKB, MySqlParserMULTIPOINTFROMTEXT, MySqlParserMULTIPOINTFROMWKB, MySqlParserMULTIPOLYGONFROMTEXT, MySqlParserMULTIPOLYGONFROMWKB, MySqlParserNAME_CONST, MySqlParserNULLIF, MySqlParserNUMGEOMETRIES, MySqlParserNUMINTERIORRINGS, MySqlParserNUMPOINTS, MySqlParserOCT, MySqlParserOCTET_LENGTH, MySqlParserORD, MySqlParserOVERLAPS, MySqlParserPERIOD_ADD, MySqlParserPERIOD_DIFF, MySqlParserPI, MySqlParserPOINTFROMTEXT, MySqlParserPOINTFROMWKB, MySqlParserPOINTN, MySqlParserPOLYFROMTEXT, MySqlParserPOLYFROMWKB, MySqlParserPOLYGONFROMTEXT, MySqlParserPOLYGONFROMWKB, MySqlParserPOW, MySqlParserPOWER, MySqlParserQUOTE, MySqlParserRADIANS, MySqlParserRAND, MySqlParserRANDOM, MySqlParserRANDOM_BYTES, MySqlParserRELEASE_LOCK, MySqlParserREVERSE, MySqlParserROUND, MySqlParserROW_COUNT, MySqlParserRPAD, MySqlParserRTRIM, MySqlParserSEC_TO_TIME, MySqlParserSECONDARY_ENGINE_ATTRIBUTE, MySqlParserSESSION_USER, MySqlParserSHA, MySqlParserSHA1, MySqlParserSHA2, MySqlParserSCHEMA_NAME, MySqlParserSIGN, MySqlParserSIN, MySqlParserSLEEP, MySqlParserSOUNDEX, MySqlParserSQL_THREAD_WAIT_AFTER_GTIDS, MySqlParserSQRT, MySqlParserSRID, MySqlParserSTARTPOINT, MySqlParserSTRCMP, MySqlParserSTR_TO_DATE, MySqlParserST_AREA, MySqlParserST_ASBINARY, MySqlParserST_ASTEXT, MySqlParserST_ASWKB, MySqlParserST_ASWKT, MySqlParserST_BUFFER, MySqlParserST_CENTROID, MySqlParserST_CONTAINS, MySqlParserST_CROSSES, MySqlParserST_DIFFERENCE, MySqlParserST_DIMENSION, MySqlParserST_DISJOINT, MySqlParserST_DISTANCE, MySqlParserST_ENDPOINT, MySqlParserST_ENVELOPE, MySqlParserST_EQUALS, MySqlParserST_EXTERIORRING, MySqlParserST_GEOMCOLLFROMTEXT, MySqlParserST_GEOMCOLLFROMTXT, MySqlParserST_GEOMCOLLFROMWKB, MySqlParserST_GEOMETRYCOLLECTIONFROMTEXT, MySqlParserST_GEOMETRYCOLLECTIONFROMWKB, MySqlParserST_GEOMETRYFROMTEXT, MySqlParserST_GEOMETRYFROMWKB, MySqlParserST_GEOMETRYN, MySqlParserST_GEOMETRYTYPE, MySqlParserST_GEOMFROMTEXT, MySqlParserST_GEOMFROMWKB, MySqlParserST_INTERIORRINGN, MySqlParserST_INTERSECTION, MySqlParserST_INTERSECTS, MySqlParserST_ISCLOSED, MySqlParserST_ISEMPTY, MySqlParserST_ISSIMPLE, MySqlParserST_LINEFROMTEXT, MySqlParserST_LINEFROMWKB, MySqlParserST_LINESTRINGFROMTEXT, MySqlParserST_LINESTRINGFROMWKB, MySqlParserST_NUMGEOMETRIES, MySqlParserST_NUMINTERIORRING, MySqlParserST_NUMINTERIORRINGS, MySqlParserST_NUMPOINTS, MySqlParserST_OVERLAPS, MySqlParserST_POINTFROMTEXT, MySqlParserST_POINTFROMWKB, MySqlParserST_POINTN, MySqlParserST_POLYFROMTEXT, MySqlParserST_POLYFROMWKB, MySqlParserST_POLYGONFROMTEXT, MySqlParserST_POLYGONFROMWKB, MySqlParserST_SRID, MySqlParserST_STARTPOINT, MySqlParserST_SYMDIFFERENCE, MySqlParserST_TOUCHES, MySqlParserST_UNION, MySqlParserST_WITHIN, MySqlParserST_X, MySqlParserST_Y, MySqlParserSTRING_TO_VECTOR, MySqlParserSUBDATE, MySqlParserSUBSTRING_INDEX, MySqlParserSUBTIME, MySqlParserSYSTEM_USER, MySqlParserTAN, MySqlParserTIMEDIFF, MySqlParserTIMESTAMPADD, MySqlParserTIMESTAMPDIFF, MySqlParserTIME_FORMAT, MySqlParserTIME_TO_SEC, MySqlParserTOUCHES, MySqlParserTO_BASE64, MySqlParserTO_DAYS, MySqlParserTO_SECONDS, MySqlParserTP_CONNECTION_ADMIN, MySqlParserUCASE, MySqlParserUNCOMPRESS, MySqlParserUNCOMPRESSED_LENGTH, MySqlParserUNHEX, MySqlParserUNIX_TIMESTAMP, MySqlParserUPDATEXML, MySqlParserUPPER, MySqlParserUUID, MySqlParserUUID_SHORT, MySqlParserVALIDATE_PASSWORD_STRENGTH, MySqlParserVECTOR_DIM, MySqlParserVECTOR_TO_STRING, MySqlParserVERSION, MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS, MySqlParserWEEKDAY, MySqlParserWEEKOFYEAR, MySqlParserWEIGHT_STRING, MySqlParserWITHIN, MySqlParserYEARWEEK, MySqlParserY_FUNCTION, MySqlParserX_FUNCTION, MySqlParserMOD, MySqlParserCHARSET_REVERSE_QOUTE_STRING, MySqlParserSTRING_LITERAL, MySqlParserID: + { + p.SetState(5269) + p.Uid() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(5274) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5275) + p.Match(MySqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5277) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 781, p.GetParserRuleContext()) == 1 { + { + p.SetState(5276) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*DetailRevokeContext).privilegeObject = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserPROCEDURE || _la == MySqlParserTABLE || _la == MySqlParserFUNCTION) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*DetailRevokeContext).privilegeObject = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5279) + p.PrivilegeLevel() + } + { + p.SetState(5280) + p.Match(MySqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5281) + p.UserName() + } + p.SetState(5286) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(5282) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5283) + p.UserName() + } + + p.SetState(5288) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(5292) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserIGNORE { + { + p.SetState(5289) + p.Match(MySqlParserIGNORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5290) + p.Match(MySqlParserUNKNOWN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5291) + p.Match(MySqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 2: + localctx = NewShortRevokeContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5294) + p.Match(MySqlParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5296) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserIF { + { + p.SetState(5295) + p.IfExists() + } + + } + { + p.SetState(5298) + p.Match(MySqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5300) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserPRIVILEGES { + { + p.SetState(5299) + p.Match(MySqlParserPRIVILEGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5302) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5303) + p.Match(MySqlParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5304) + p.Match(MySqlParserOPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5305) + p.Match(MySqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5306) + p.UserName() + } + p.SetState(5311) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(5307) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5308) + p.UserName() + } + + p.SetState(5313) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(5317) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserIGNORE { + { + p.SetState(5314) + p.Match(MySqlParserIGNORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5315) + p.Match(MySqlParserUNKNOWN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5316) + p.Match(MySqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 3: + localctx = NewRoleRevokeContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5319) + p.Match(MySqlParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5321) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 788, p.GetParserRuleContext()) == 1 { + { + p.SetState(5320) + p.IfExists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5325) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 789, p.GetParserRuleContext()) { + case 1: + { + p.SetState(5323) + p.UserName() + } + + case 2: + { + p.SetState(5324) + p.Uid() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(5334) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(5327) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5330) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 790, p.GetParserRuleContext()) { + case 1: + { + p.SetState(5328) + p.UserName() + } + + case 2: + { + p.SetState(5329) + p.Uid() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(5336) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5337) + p.Match(MySqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5340) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 792, p.GetParserRuleContext()) { + case 1: + { + p.SetState(5338) + p.UserName() + } + + case 2: + { + p.SetState(5339) + p.Uid() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(5349) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(5342) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5345) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 793, p.GetParserRuleContext()) { + case 1: + { + p.SetState(5343) + p.UserName() + } + + case 2: + { + p.SetState(5344) + p.Uid() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(5351) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(5355) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserIGNORE { + { + p.SetState(5352) + p.Match(MySqlParserIGNORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5353) + p.Match(MySqlParserUNKNOWN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5354) + p.Match(MySqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRevokeProxyContext is an interface to support dynamic dispatch. +type IRevokeProxyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetOnUser returns the onUser rule contexts. + GetOnUser() IUserNameContext + + // GetFromFirst returns the fromFirst rule contexts. + GetFromFirst() IUserNameContext + + // Get_userName returns the _userName rule contexts. + Get_userName() IUserNameContext + + // SetOnUser sets the onUser rule contexts. + SetOnUser(IUserNameContext) + + // SetFromFirst sets the fromFirst rule contexts. + SetFromFirst(IUserNameContext) + + // Set_userName sets the _userName rule contexts. + Set_userName(IUserNameContext) + + // GetFromOther returns the fromOther rule context list. + GetFromOther() []IUserNameContext + + // SetFromOther sets the fromOther rule context list. + SetFromOther([]IUserNameContext) + + // Getter signatures + REVOKE() antlr.TerminalNode + PROXY() antlr.TerminalNode + ON() antlr.TerminalNode + FROM() antlr.TerminalNode + AllUserName() []IUserNameContext + UserName(i int) IUserNameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsRevokeProxyContext differentiates from other interfaces. + IsRevokeProxyContext() +} + +type RevokeProxyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + onUser IUserNameContext + fromFirst IUserNameContext + _userName IUserNameContext + fromOther []IUserNameContext +} + +func NewEmptyRevokeProxyContext() *RevokeProxyContext { + var p = new(RevokeProxyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_revokeProxy + return p +} + +func InitEmptyRevokeProxyContext(p *RevokeProxyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_revokeProxy +} + +func (*RevokeProxyContext) IsRevokeProxyContext() {} + +func NewRevokeProxyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RevokeProxyContext { + var p = new(RevokeProxyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_revokeProxy + + return p +} + +func (s *RevokeProxyContext) GetParser() antlr.Parser { return s.parser } + +func (s *RevokeProxyContext) GetOnUser() IUserNameContext { return s.onUser } + +func (s *RevokeProxyContext) GetFromFirst() IUserNameContext { return s.fromFirst } + +func (s *RevokeProxyContext) Get_userName() IUserNameContext { return s._userName } + +func (s *RevokeProxyContext) SetOnUser(v IUserNameContext) { s.onUser = v } + +func (s *RevokeProxyContext) SetFromFirst(v IUserNameContext) { s.fromFirst = v } + +func (s *RevokeProxyContext) Set_userName(v IUserNameContext) { s._userName = v } + +func (s *RevokeProxyContext) GetFromOther() []IUserNameContext { return s.fromOther } + +func (s *RevokeProxyContext) SetFromOther(v []IUserNameContext) { s.fromOther = v } + +func (s *RevokeProxyContext) REVOKE() antlr.TerminalNode { + return s.GetToken(MySqlParserREVOKE, 0) +} + +func (s *RevokeProxyContext) PROXY() antlr.TerminalNode { + return s.GetToken(MySqlParserPROXY, 0) +} + +func (s *RevokeProxyContext) ON() antlr.TerminalNode { + return s.GetToken(MySqlParserON, 0) +} + +func (s *RevokeProxyContext) FROM() antlr.TerminalNode { + return s.GetToken(MySqlParserFROM, 0) +} + +func (s *RevokeProxyContext) AllUserName() []IUserNameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUserNameContext); ok { + len++ + } + } + + tst := make([]IUserNameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUserNameContext); ok { + tst[i] = t.(IUserNameContext) + i++ + } + } + + return tst +} + +func (s *RevokeProxyContext) UserName(i int) IUserNameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserNameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUserNameContext) +} + +func (s *RevokeProxyContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *RevokeProxyContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *RevokeProxyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RevokeProxyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RevokeProxyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterRevokeProxy(s) + } +} + +func (s *RevokeProxyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitRevokeProxy(s) + } +} + +func (p *MySqlParser) RevokeProxy() (localctx IRevokeProxyContext) { + localctx = NewRevokeProxyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 442, MySqlParserRULE_revokeProxy) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5359) + p.Match(MySqlParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5360) + p.Match(MySqlParserPROXY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5361) + p.Match(MySqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5362) + + var _x = p.UserName() + + localctx.(*RevokeProxyContext).onUser = _x + } + { + p.SetState(5363) + p.Match(MySqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5364) + + var _x = p.UserName() + + localctx.(*RevokeProxyContext).fromFirst = _x + } + p.SetState(5369) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(5365) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5366) + + var _x = p.UserName() + + localctx.(*RevokeProxyContext)._userName = _x + } + localctx.(*RevokeProxyContext).fromOther = append(localctx.(*RevokeProxyContext).fromOther, localctx.(*RevokeProxyContext)._userName) + + p.SetState(5371) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISetPasswordStatementContext is an interface to support dynamic dispatch. +type ISetPasswordStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + PASSWORD() antlr.TerminalNode + EQUAL_SYMBOL() antlr.TerminalNode + PasswordFunctionClause() IPasswordFunctionClauseContext + STRING_LITERAL() antlr.TerminalNode + FOR() antlr.TerminalNode + UserName() IUserNameContext + + // IsSetPasswordStatementContext differentiates from other interfaces. + IsSetPasswordStatementContext() +} + +type SetPasswordStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySetPasswordStatementContext() *SetPasswordStatementContext { + var p = new(SetPasswordStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_setPasswordStatement + return p +} + +func InitEmptySetPasswordStatementContext(p *SetPasswordStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_setPasswordStatement +} + +func (*SetPasswordStatementContext) IsSetPasswordStatementContext() {} + +func NewSetPasswordStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SetPasswordStatementContext { + var p = new(SetPasswordStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_setPasswordStatement + + return p +} + +func (s *SetPasswordStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *SetPasswordStatementContext) SET() antlr.TerminalNode { + return s.GetToken(MySqlParserSET, 0) +} + +func (s *SetPasswordStatementContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(MySqlParserPASSWORD, 0) +} + +func (s *SetPasswordStatementContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *SetPasswordStatementContext) PasswordFunctionClause() IPasswordFunctionClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPasswordFunctionClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPasswordFunctionClauseContext) +} + +func (s *SetPasswordStatementContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *SetPasswordStatementContext) FOR() antlr.TerminalNode { + return s.GetToken(MySqlParserFOR, 0) +} + +func (s *SetPasswordStatementContext) UserName() IUserNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUserNameContext) +} + +func (s *SetPasswordStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SetPasswordStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SetPasswordStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSetPasswordStatement(s) + } +} + +func (s *SetPasswordStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSetPasswordStatement(s) + } +} + +func (p *MySqlParser) SetPasswordStatement() (localctx ISetPasswordStatementContext) { + localctx = NewSetPasswordStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 444, MySqlParserRULE_setPasswordStatement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5372) + p.Match(MySqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5373) + p.Match(MySqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5376) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserFOR { + { + p.SetState(5374) + p.Match(MySqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5375) + p.UserName() + } + + } + { + p.SetState(5378) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5381) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserOLD_PASSWORD, MySqlParserPASSWORD: + { + p.SetState(5379) + p.PasswordFunctionClause() + } + + case MySqlParserSTRING_LITERAL: + { + p.SetState(5380) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUserSpecificationContext is an interface to support dynamic dispatch. +type IUserSpecificationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UserName() IUserNameContext + UserPasswordOption() IUserPasswordOptionContext + + // IsUserSpecificationContext differentiates from other interfaces. + IsUserSpecificationContext() +} + +type UserSpecificationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUserSpecificationContext() *UserSpecificationContext { + var p = new(UserSpecificationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_userSpecification + return p +} + +func InitEmptyUserSpecificationContext(p *UserSpecificationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_userSpecification +} + +func (*UserSpecificationContext) IsUserSpecificationContext() {} + +func NewUserSpecificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UserSpecificationContext { + var p = new(UserSpecificationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_userSpecification + + return p +} + +func (s *UserSpecificationContext) GetParser() antlr.Parser { return s.parser } + +func (s *UserSpecificationContext) UserName() IUserNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUserNameContext) +} + +func (s *UserSpecificationContext) UserPasswordOption() IUserPasswordOptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserPasswordOptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUserPasswordOptionContext) +} + +func (s *UserSpecificationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UserSpecificationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *UserSpecificationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterUserSpecification(s) + } +} + +func (s *UserSpecificationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitUserSpecification(s) + } +} + +func (p *MySqlParser) UserSpecification() (localctx IUserSpecificationContext) { + localctx = NewUserSpecificationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 446, MySqlParserRULE_userSpecification) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5383) + p.UserName() + } + { + p.SetState(5384) + p.UserPasswordOption() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUserAuthOptionContext is an interface to support dynamic dispatch. +type IUserAuthOptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsUserAuthOptionContext differentiates from other interfaces. + IsUserAuthOptionContext() +} + +type UserAuthOptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUserAuthOptionContext() *UserAuthOptionContext { + var p = new(UserAuthOptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_userAuthOption + return p +} + +func InitEmptyUserAuthOptionContext(p *UserAuthOptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_userAuthOption +} + +func (*UserAuthOptionContext) IsUserAuthOptionContext() {} + +func NewUserAuthOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UserAuthOptionContext { + var p = new(UserAuthOptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_userAuthOption + + return p +} + +func (s *UserAuthOptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *UserAuthOptionContext) CopyAll(ctx *UserAuthOptionContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *UserAuthOptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UserAuthOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type SimpleAuthOptionContext struct { + UserAuthOptionContext +} + +func NewSimpleAuthOptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SimpleAuthOptionContext { + var p = new(SimpleAuthOptionContext) + + InitEmptyUserAuthOptionContext(&p.UserAuthOptionContext) + p.parser = parser + p.CopyAll(ctx.(*UserAuthOptionContext)) + + return p +} + +func (s *SimpleAuthOptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SimpleAuthOptionContext) UserName() IUserNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUserNameContext) +} + +func (s *SimpleAuthOptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSimpleAuthOption(s) + } +} + +func (s *SimpleAuthOptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSimpleAuthOption(s) + } +} + +type ModuleAuthOptionContext struct { + UserAuthOptionContext +} + +func NewModuleAuthOptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ModuleAuthOptionContext { + var p = new(ModuleAuthOptionContext) + + InitEmptyUserAuthOptionContext(&p.UserAuthOptionContext) + p.parser = parser + p.CopyAll(ctx.(*UserAuthOptionContext)) + + return p +} + +func (s *ModuleAuthOptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ModuleAuthOptionContext) UserName() IUserNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUserNameContext) +} + +func (s *ModuleAuthOptionContext) IDENTIFIED() antlr.TerminalNode { + return s.GetToken(MySqlParserIDENTIFIED, 0) +} + +func (s *ModuleAuthOptionContext) WITH() antlr.TerminalNode { + return s.GetToken(MySqlParserWITH, 0) +} + +func (s *ModuleAuthOptionContext) AuthenticationRule() IAuthenticationRuleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAuthenticationRuleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAuthenticationRuleContext) +} + +func (s *ModuleAuthOptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterModuleAuthOption(s) + } +} + +func (s *ModuleAuthOptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitModuleAuthOption(s) + } +} + +type RandomAuthOptionContext struct { + UserAuthOptionContext +} + +func NewRandomAuthOptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RandomAuthOptionContext { + var p = new(RandomAuthOptionContext) + + InitEmptyUserAuthOptionContext(&p.UserAuthOptionContext) + p.parser = parser + p.CopyAll(ctx.(*UserAuthOptionContext)) + + return p +} + +func (s *RandomAuthOptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RandomAuthOptionContext) UserName() IUserNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUserNameContext) +} + +func (s *RandomAuthOptionContext) IDENTIFIED() antlr.TerminalNode { + return s.GetToken(MySqlParserIDENTIFIED, 0) +} + +func (s *RandomAuthOptionContext) BY() antlr.TerminalNode { + return s.GetToken(MySqlParserBY, 0) +} + +func (s *RandomAuthOptionContext) RANDOM() antlr.TerminalNode { + return s.GetToken(MySqlParserRANDOM, 0) +} + +func (s *RandomAuthOptionContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(MySqlParserPASSWORD, 0) +} + +func (s *RandomAuthOptionContext) AuthOptionClause() IAuthOptionClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAuthOptionClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAuthOptionClauseContext) +} + +func (s *RandomAuthOptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterRandomAuthOption(s) + } +} + +func (s *RandomAuthOptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitRandomAuthOption(s) + } +} + +type StringAuthOptionContext struct { + UserAuthOptionContext +} + +func NewStringAuthOptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StringAuthOptionContext { + var p = new(StringAuthOptionContext) + + InitEmptyUserAuthOptionContext(&p.UserAuthOptionContext) + p.parser = parser + p.CopyAll(ctx.(*UserAuthOptionContext)) + + return p +} + +func (s *StringAuthOptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *StringAuthOptionContext) UserName() IUserNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUserNameContext) +} + +func (s *StringAuthOptionContext) IDENTIFIED() antlr.TerminalNode { + return s.GetToken(MySqlParserIDENTIFIED, 0) +} + +func (s *StringAuthOptionContext) BY() antlr.TerminalNode { + return s.GetToken(MySqlParserBY, 0) +} + +func (s *StringAuthOptionContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *StringAuthOptionContext) AuthOptionClause() IAuthOptionClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAuthOptionClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAuthOptionClauseContext) +} + +func (s *StringAuthOptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterStringAuthOption(s) + } +} + +func (s *StringAuthOptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitStringAuthOption(s) + } +} + +type HashAuthOptionContext struct { + UserAuthOptionContext + hashed antlr.Token +} + +func NewHashAuthOptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *HashAuthOptionContext { + var p = new(HashAuthOptionContext) + + InitEmptyUserAuthOptionContext(&p.UserAuthOptionContext) + p.parser = parser + p.CopyAll(ctx.(*UserAuthOptionContext)) + + return p +} + +func (s *HashAuthOptionContext) GetHashed() antlr.Token { return s.hashed } + +func (s *HashAuthOptionContext) SetHashed(v antlr.Token) { s.hashed = v } + +func (s *HashAuthOptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *HashAuthOptionContext) UserName() IUserNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUserNameContext) +} + +func (s *HashAuthOptionContext) IDENTIFIED() antlr.TerminalNode { + return s.GetToken(MySqlParserIDENTIFIED, 0) +} + +func (s *HashAuthOptionContext) BY() antlr.TerminalNode { + return s.GetToken(MySqlParserBY, 0) +} + +func (s *HashAuthOptionContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(MySqlParserPASSWORD, 0) +} + +func (s *HashAuthOptionContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *HashAuthOptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterHashAuthOption(s) + } +} + +func (s *HashAuthOptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitHashAuthOption(s) + } +} + +func (p *MySqlParser) UserAuthOption() (localctx IUserAuthOptionContext) { + localctx = NewUserAuthOptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 448, MySqlParserRULE_userAuthOption) + p.SetState(5411) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 800, p.GetParserRuleContext()) { + case 1: + localctx = NewHashAuthOptionContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5386) + p.UserName() + } + { + p.SetState(5387) + p.Match(MySqlParserIDENTIFIED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5388) + p.Match(MySqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5389) + p.Match(MySqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5390) + + var _m = p.Match(MySqlParserSTRING_LITERAL) + + localctx.(*HashAuthOptionContext).hashed = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + localctx = NewRandomAuthOptionContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5392) + p.UserName() + } + { + p.SetState(5393) + p.Match(MySqlParserIDENTIFIED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5394) + p.Match(MySqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5395) + p.Match(MySqlParserRANDOM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5396) + p.Match(MySqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5397) + p.AuthOptionClause() + } + + case 3: + localctx = NewStringAuthOptionContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5399) + p.UserName() + } + { + p.SetState(5400) + p.Match(MySqlParserIDENTIFIED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5401) + p.Match(MySqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5402) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5403) + p.AuthOptionClause() + } + + case 4: + localctx = NewModuleAuthOptionContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5405) + p.UserName() + } + { + p.SetState(5406) + p.Match(MySqlParserIDENTIFIED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5407) + p.Match(MySqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5408) + p.AuthenticationRule() + } + + case 5: + localctx = NewSimpleAuthOptionContext(p, localctx) + p.EnterOuterAlt(localctx, 5) + { + p.SetState(5410) + p.UserName() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAuthOptionClauseContext is an interface to support dynamic dispatch. +type IAuthOptionClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REPLACE() antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + RETAIN() antlr.TerminalNode + CURRENT() antlr.TerminalNode + PASSWORD() antlr.TerminalNode + + // IsAuthOptionClauseContext differentiates from other interfaces. + IsAuthOptionClauseContext() +} + +type AuthOptionClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAuthOptionClauseContext() *AuthOptionClauseContext { + var p = new(AuthOptionClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_authOptionClause + return p +} + +func InitEmptyAuthOptionClauseContext(p *AuthOptionClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_authOptionClause +} + +func (*AuthOptionClauseContext) IsAuthOptionClauseContext() {} + +func NewAuthOptionClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AuthOptionClauseContext { + var p = new(AuthOptionClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_authOptionClause + + return p +} + +func (s *AuthOptionClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *AuthOptionClauseContext) REPLACE() antlr.TerminalNode { + return s.GetToken(MySqlParserREPLACE, 0) +} + +func (s *AuthOptionClauseContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *AuthOptionClauseContext) RETAIN() antlr.TerminalNode { + return s.GetToken(MySqlParserRETAIN, 0) +} + +func (s *AuthOptionClauseContext) CURRENT() antlr.TerminalNode { + return s.GetToken(MySqlParserCURRENT, 0) +} + +func (s *AuthOptionClauseContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(MySqlParserPASSWORD, 0) +} + +func (s *AuthOptionClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AuthOptionClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AuthOptionClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAuthOptionClause(s) + } +} + +func (s *AuthOptionClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAuthOptionClause(s) + } +} + +func (p *MySqlParser) AuthOptionClause() (localctx IAuthOptionClauseContext) { + localctx = NewAuthOptionClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 450, MySqlParserRULE_authOptionClause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(5415) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 801, p.GetParserRuleContext()) == 1 { + { + p.SetState(5413) + p.Match(MySqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5414) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5420) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserRETAIN { + { + p.SetState(5417) + p.Match(MySqlParserRETAIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5418) + p.Match(MySqlParserCURRENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5419) + p.Match(MySqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAuthenticationRuleContext is an interface to support dynamic dispatch. +type IAuthenticationRuleContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsAuthenticationRuleContext differentiates from other interfaces. + IsAuthenticationRuleContext() +} + +type AuthenticationRuleContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAuthenticationRuleContext() *AuthenticationRuleContext { + var p = new(AuthenticationRuleContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_authenticationRule + return p +} + +func InitEmptyAuthenticationRuleContext(p *AuthenticationRuleContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_authenticationRule +} + +func (*AuthenticationRuleContext) IsAuthenticationRuleContext() {} + +func NewAuthenticationRuleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AuthenticationRuleContext { + var p = new(AuthenticationRuleContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_authenticationRule + + return p +} + +func (s *AuthenticationRuleContext) GetParser() antlr.Parser { return s.parser } + +func (s *AuthenticationRuleContext) CopyAll(ctx *AuthenticationRuleContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *AuthenticationRuleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AuthenticationRuleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type PasswordModuleOptionContext struct { + AuthenticationRuleContext +} + +func NewPasswordModuleOptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PasswordModuleOptionContext { + var p = new(PasswordModuleOptionContext) + + InitEmptyAuthenticationRuleContext(&p.AuthenticationRuleContext) + p.parser = parser + p.CopyAll(ctx.(*AuthenticationRuleContext)) + + return p +} + +func (s *PasswordModuleOptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PasswordModuleOptionContext) AuthPlugin() IAuthPluginContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAuthPluginContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAuthPluginContext) +} + +func (s *PasswordModuleOptionContext) USING() antlr.TerminalNode { + return s.GetToken(MySqlParserUSING, 0) +} + +func (s *PasswordModuleOptionContext) PasswordFunctionClause() IPasswordFunctionClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPasswordFunctionClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPasswordFunctionClauseContext) +} + +func (s *PasswordModuleOptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterPasswordModuleOption(s) + } +} + +func (s *PasswordModuleOptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitPasswordModuleOption(s) + } +} + +type ModuleContext struct { + AuthenticationRuleContext +} + +func NewModuleContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ModuleContext { + var p = new(ModuleContext) + + InitEmptyAuthenticationRuleContext(&p.AuthenticationRuleContext) + p.parser = parser + p.CopyAll(ctx.(*AuthenticationRuleContext)) + + return p +} + +func (s *ModuleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ModuleContext) AuthPlugin() IAuthPluginContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAuthPluginContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAuthPluginContext) +} + +func (s *ModuleContext) AuthOptionClause() IAuthOptionClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAuthOptionClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAuthOptionClauseContext) +} + +func (s *ModuleContext) BY() antlr.TerminalNode { + return s.GetToken(MySqlParserBY, 0) +} + +func (s *ModuleContext) USING() antlr.TerminalNode { + return s.GetToken(MySqlParserUSING, 0) +} + +func (s *ModuleContext) AS() antlr.TerminalNode { + return s.GetToken(MySqlParserAS, 0) +} + +func (s *ModuleContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *ModuleContext) RANDOM() antlr.TerminalNode { + return s.GetToken(MySqlParserRANDOM, 0) +} + +func (s *ModuleContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(MySqlParserPASSWORD, 0) +} + +func (s *ModuleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterModule(s) + } +} + +func (s *ModuleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitModule(s) + } +} + +func (p *MySqlParser) AuthenticationRule() (localctx IAuthenticationRuleContext) { + localctx = NewAuthenticationRuleContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 452, MySqlParserRULE_authenticationRule) + var _la int + + p.SetState(5436) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 805, p.GetParserRuleContext()) { + case 1: + localctx = NewModuleContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5422) + p.AuthPlugin() + } + p.SetState(5430) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 804, p.GetParserRuleContext()) == 1 { + { + p.SetState(5423) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserAS || _la == MySqlParserBY || _la == MySqlParserUSING) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(5427) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserSTRING_LITERAL: + { + p.SetState(5424) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserRANDOM: + { + p.SetState(5425) + p.Match(MySqlParserRANDOM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5426) + p.Match(MySqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(5429) + p.AuthOptionClause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + localctx = NewPasswordModuleOptionContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5432) + p.AuthPlugin() + } + { + p.SetState(5433) + p.Match(MySqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5434) + p.PasswordFunctionClause() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITlsOptionContext is an interface to support dynamic dispatch. +type ITlsOptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SSL() antlr.TerminalNode + X509() antlr.TerminalNode + CIPHER() antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + ISSUER() antlr.TerminalNode + SUBJECT() antlr.TerminalNode + + // IsTlsOptionContext differentiates from other interfaces. + IsTlsOptionContext() +} + +type TlsOptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTlsOptionContext() *TlsOptionContext { + var p = new(TlsOptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_tlsOption + return p +} + +func InitEmptyTlsOptionContext(p *TlsOptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_tlsOption +} + +func (*TlsOptionContext) IsTlsOptionContext() {} + +func NewTlsOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TlsOptionContext { + var p = new(TlsOptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_tlsOption + + return p +} + +func (s *TlsOptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *TlsOptionContext) SSL() antlr.TerminalNode { + return s.GetToken(MySqlParserSSL, 0) +} + +func (s *TlsOptionContext) X509() antlr.TerminalNode { + return s.GetToken(MySqlParserX509, 0) +} + +func (s *TlsOptionContext) CIPHER() antlr.TerminalNode { + return s.GetToken(MySqlParserCIPHER, 0) +} + +func (s *TlsOptionContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *TlsOptionContext) ISSUER() antlr.TerminalNode { + return s.GetToken(MySqlParserISSUER, 0) +} + +func (s *TlsOptionContext) SUBJECT() antlr.TerminalNode { + return s.GetToken(MySqlParserSUBJECT, 0) +} + +func (s *TlsOptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TlsOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TlsOptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTlsOption(s) + } +} + +func (s *TlsOptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTlsOption(s) + } +} + +func (p *MySqlParser) TlsOption() (localctx ITlsOptionContext) { + localctx = NewTlsOptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 454, MySqlParserRULE_tlsOption) + p.SetState(5446) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserSSL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5438) + p.Match(MySqlParserSSL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserX509: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5439) + p.Match(MySqlParserX509) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserCIPHER: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5440) + p.Match(MySqlParserCIPHER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5441) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserISSUER: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5442) + p.Match(MySqlParserISSUER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5443) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserSUBJECT: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(5444) + p.Match(MySqlParserSUBJECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5445) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUserResourceOptionContext is an interface to support dynamic dispatch. +type IUserResourceOptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MAX_QUERIES_PER_HOUR() antlr.TerminalNode + DecimalLiteral() IDecimalLiteralContext + MAX_UPDATES_PER_HOUR() antlr.TerminalNode + MAX_CONNECTIONS_PER_HOUR() antlr.TerminalNode + MAX_USER_CONNECTIONS() antlr.TerminalNode + + // IsUserResourceOptionContext differentiates from other interfaces. + IsUserResourceOptionContext() +} + +type UserResourceOptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUserResourceOptionContext() *UserResourceOptionContext { + var p = new(UserResourceOptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_userResourceOption + return p +} + +func InitEmptyUserResourceOptionContext(p *UserResourceOptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_userResourceOption +} + +func (*UserResourceOptionContext) IsUserResourceOptionContext() {} + +func NewUserResourceOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UserResourceOptionContext { + var p = new(UserResourceOptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_userResourceOption + + return p +} + +func (s *UserResourceOptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *UserResourceOptionContext) MAX_QUERIES_PER_HOUR() antlr.TerminalNode { + return s.GetToken(MySqlParserMAX_QUERIES_PER_HOUR, 0) +} + +func (s *UserResourceOptionContext) DecimalLiteral() IDecimalLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *UserResourceOptionContext) MAX_UPDATES_PER_HOUR() antlr.TerminalNode { + return s.GetToken(MySqlParserMAX_UPDATES_PER_HOUR, 0) +} + +func (s *UserResourceOptionContext) MAX_CONNECTIONS_PER_HOUR() antlr.TerminalNode { + return s.GetToken(MySqlParserMAX_CONNECTIONS_PER_HOUR, 0) +} + +func (s *UserResourceOptionContext) MAX_USER_CONNECTIONS() antlr.TerminalNode { + return s.GetToken(MySqlParserMAX_USER_CONNECTIONS, 0) +} + +func (s *UserResourceOptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UserResourceOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *UserResourceOptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterUserResourceOption(s) + } +} + +func (s *UserResourceOptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitUserResourceOption(s) + } +} + +func (p *MySqlParser) UserResourceOption() (localctx IUserResourceOptionContext) { + localctx = NewUserResourceOptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 456, MySqlParserRULE_userResourceOption) + p.SetState(5456) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserMAX_QUERIES_PER_HOUR: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5448) + p.Match(MySqlParserMAX_QUERIES_PER_HOUR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5449) + p.DecimalLiteral() + } + + case MySqlParserMAX_UPDATES_PER_HOUR: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5450) + p.Match(MySqlParserMAX_UPDATES_PER_HOUR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5451) + p.DecimalLiteral() + } + + case MySqlParserMAX_CONNECTIONS_PER_HOUR: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5452) + p.Match(MySqlParserMAX_CONNECTIONS_PER_HOUR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5453) + p.DecimalLiteral() + } + + case MySqlParserMAX_USER_CONNECTIONS: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5454) + p.Match(MySqlParserMAX_USER_CONNECTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5455) + p.DecimalLiteral() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUserPasswordOptionContext is an interface to support dynamic dispatch. +type IUserPasswordOptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetExpireType returns the expireType token. + GetExpireType() antlr.Token + + // SetExpireType sets the expireType token. + SetExpireType(antlr.Token) + + // Getter signatures + PASSWORD() antlr.TerminalNode + EXPIRE() antlr.TerminalNode + DecimalLiteral() IDecimalLiteralContext + DAY() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + NEVER() antlr.TerminalNode + INTERVAL() antlr.TerminalNode + HISTORY() antlr.TerminalNode + REUSE() antlr.TerminalNode + REQUIRE() antlr.TerminalNode + CURRENT() antlr.TerminalNode + OPTIONAL() antlr.TerminalNode + FAILED_LOGIN_ATTEMPTS() antlr.TerminalNode + PASSWORD_LOCK_TIME() antlr.TerminalNode + UNBOUNDED() antlr.TerminalNode + + // IsUserPasswordOptionContext differentiates from other interfaces. + IsUserPasswordOptionContext() +} + +type UserPasswordOptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + expireType antlr.Token +} + +func NewEmptyUserPasswordOptionContext() *UserPasswordOptionContext { + var p = new(UserPasswordOptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_userPasswordOption + return p +} + +func InitEmptyUserPasswordOptionContext(p *UserPasswordOptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_userPasswordOption +} + +func (*UserPasswordOptionContext) IsUserPasswordOptionContext() {} + +func NewUserPasswordOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UserPasswordOptionContext { + var p = new(UserPasswordOptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_userPasswordOption + + return p +} + +func (s *UserPasswordOptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *UserPasswordOptionContext) GetExpireType() antlr.Token { return s.expireType } + +func (s *UserPasswordOptionContext) SetExpireType(v antlr.Token) { s.expireType = v } + +func (s *UserPasswordOptionContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(MySqlParserPASSWORD, 0) +} + +func (s *UserPasswordOptionContext) EXPIRE() antlr.TerminalNode { + return s.GetToken(MySqlParserEXPIRE, 0) +} + +func (s *UserPasswordOptionContext) DecimalLiteral() IDecimalLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *UserPasswordOptionContext) DAY() antlr.TerminalNode { + return s.GetToken(MySqlParserDAY, 0) +} + +func (s *UserPasswordOptionContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(MySqlParserDEFAULT, 0) +} + +func (s *UserPasswordOptionContext) NEVER() antlr.TerminalNode { + return s.GetToken(MySqlParserNEVER, 0) +} + +func (s *UserPasswordOptionContext) INTERVAL() antlr.TerminalNode { + return s.GetToken(MySqlParserINTERVAL, 0) +} + +func (s *UserPasswordOptionContext) HISTORY() antlr.TerminalNode { + return s.GetToken(MySqlParserHISTORY, 0) +} + +func (s *UserPasswordOptionContext) REUSE() antlr.TerminalNode { + return s.GetToken(MySqlParserREUSE, 0) +} + +func (s *UserPasswordOptionContext) REQUIRE() antlr.TerminalNode { + return s.GetToken(MySqlParserREQUIRE, 0) +} + +func (s *UserPasswordOptionContext) CURRENT() antlr.TerminalNode { + return s.GetToken(MySqlParserCURRENT, 0) +} + +func (s *UserPasswordOptionContext) OPTIONAL() antlr.TerminalNode { + return s.GetToken(MySqlParserOPTIONAL, 0) +} + +func (s *UserPasswordOptionContext) FAILED_LOGIN_ATTEMPTS() antlr.TerminalNode { + return s.GetToken(MySqlParserFAILED_LOGIN_ATTEMPTS, 0) +} + +func (s *UserPasswordOptionContext) PASSWORD_LOCK_TIME() antlr.TerminalNode { + return s.GetToken(MySqlParserPASSWORD_LOCK_TIME, 0) +} + +func (s *UserPasswordOptionContext) UNBOUNDED() antlr.TerminalNode { + return s.GetToken(MySqlParserUNBOUNDED, 0) +} + +func (s *UserPasswordOptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UserPasswordOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *UserPasswordOptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterUserPasswordOption(s) + } +} + +func (s *UserPasswordOptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitUserPasswordOption(s) + } +} + +func (p *MySqlParser) UserPasswordOption() (localctx IUserPasswordOptionContext) { + localctx = NewUserPasswordOptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 458, MySqlParserRULE_userPasswordOption) + var _la int + + p.SetState(5496) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 813, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5458) + p.Match(MySqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5459) + p.Match(MySqlParserEXPIRE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5466) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case MySqlParserDEFAULT: + { + p.SetState(5460) + + var _m = p.Match(MySqlParserDEFAULT) + + localctx.(*UserPasswordOptionContext).expireType = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserNEVER: + { + p.SetState(5461) + + var _m = p.Match(MySqlParserNEVER) + + localctx.(*UserPasswordOptionContext).expireType = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserINTERVAL: + { + p.SetState(5462) + + var _m = p.Match(MySqlParserINTERVAL) + + localctx.(*UserPasswordOptionContext).expireType = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5463) + p.DecimalLiteral() + } + { + p.SetState(5464) + p.Match(MySqlParserDAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserEOF, MySqlParserALTER, MySqlParserANALYZE, MySqlParserATTRIBUTE, MySqlParserCALL, MySqlParserCHANGE, MySqlParserCHECK, MySqlParserCREATE, MySqlParserDELETE, MySqlParserDESC, MySqlParserDESCRIBE, MySqlParserDROP, MySqlParserEXPLAIN, MySqlParserGET, MySqlParserGRANT, MySqlParserINSERT, MySqlParserKILL, MySqlParserLOAD, MySqlParserLOCK, MySqlParserOPTIMIZE, MySqlParserPURGE, MySqlParserRELEASE, MySqlParserRENAME, MySqlParserREPLACE, MySqlParserRESIGNAL, MySqlParserREVOKE, MySqlParserSELECT, MySqlParserSET, MySqlParserSHOW, MySqlParserSIGNAL, MySqlParserTABLE, MySqlParserUNLOCK, MySqlParserUPDATE, MySqlParserUSE, MySqlParserVALUES, MySqlParserWITH, MySqlParserACCOUNT, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserCACHE, MySqlParserCHECKSUM, MySqlParserCOMMENT, MySqlParserCOMMIT, MySqlParserDEALLOCATE, MySqlParserDO, MySqlParserFAILED_LOGIN_ATTEMPTS, MySqlParserFLUSH, MySqlParserHANDLER, MySqlParserHELP, MySqlParserINSTALL, MySqlParserPASSWORD, MySqlParserPASSWORD_LOCK_TIME, MySqlParserPREPARE, MySqlParserREPAIR, MySqlParserRESET, MySqlParserROLLBACK, MySqlParserSAVEPOINT, MySqlParserSTART, MySqlParserSTOP, MySqlParserTRUNCATE, MySqlParserUNINSTALL, MySqlParserXA, MySqlParserEXECUTE, MySqlParserSHUTDOWN, MySqlParserMINUS, MySqlParserLR_BRACKET, MySqlParserCOMMA, MySqlParserSEMI: + + default: + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5468) + p.Match(MySqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5469) + p.Match(MySqlParserHISTORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5472) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserDEFAULT: + { + p.SetState(5470) + p.Match(MySqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserZERO_DECIMAL, MySqlParserONE_DECIMAL, MySqlParserTWO_DECIMAL, MySqlParserDECIMAL_LITERAL, MySqlParserREAL_LITERAL: + { + p.SetState(5471) + p.DecimalLiteral() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5474) + p.Match(MySqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5475) + p.Match(MySqlParserREUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5476) + p.Match(MySqlParserINTERVAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5481) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserDEFAULT: + { + p.SetState(5477) + p.Match(MySqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserZERO_DECIMAL, MySqlParserONE_DECIMAL, MySqlParserTWO_DECIMAL, MySqlParserDECIMAL_LITERAL, MySqlParserREAL_LITERAL: + { + p.SetState(5478) + p.DecimalLiteral() + } + { + p.SetState(5479) + p.Match(MySqlParserDAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5483) + p.Match(MySqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5484) + p.Match(MySqlParserREQUIRE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5485) + p.Match(MySqlParserCURRENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5487) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserDEFAULT || _la == MySqlParserOPTIONAL { + { + p.SetState(5486) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserDEFAULT || _la == MySqlParserOPTIONAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(5489) + p.Match(MySqlParserFAILED_LOGIN_ATTEMPTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5490) + p.DecimalLiteral() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(5491) + p.Match(MySqlParserPASSWORD_LOCK_TIME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5494) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserZERO_DECIMAL, MySqlParserONE_DECIMAL, MySqlParserTWO_DECIMAL, MySqlParserDECIMAL_LITERAL, MySqlParserREAL_LITERAL: + { + p.SetState(5492) + p.DecimalLiteral() + } + + case MySqlParserUNBOUNDED: + { + p.SetState(5493) + p.Match(MySqlParserUNBOUNDED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUserLockOptionContext is an interface to support dynamic dispatch. +type IUserLockOptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetLockType returns the lockType token. + GetLockType() antlr.Token + + // SetLockType sets the lockType token. + SetLockType(antlr.Token) + + // Getter signatures + ACCOUNT() antlr.TerminalNode + LOCK() antlr.TerminalNode + UNLOCK() antlr.TerminalNode + + // IsUserLockOptionContext differentiates from other interfaces. + IsUserLockOptionContext() +} + +type UserLockOptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + lockType antlr.Token +} + +func NewEmptyUserLockOptionContext() *UserLockOptionContext { + var p = new(UserLockOptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_userLockOption + return p +} + +func InitEmptyUserLockOptionContext(p *UserLockOptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_userLockOption +} + +func (*UserLockOptionContext) IsUserLockOptionContext() {} + +func NewUserLockOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UserLockOptionContext { + var p = new(UserLockOptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_userLockOption + + return p +} + +func (s *UserLockOptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *UserLockOptionContext) GetLockType() antlr.Token { return s.lockType } + +func (s *UserLockOptionContext) SetLockType(v antlr.Token) { s.lockType = v } + +func (s *UserLockOptionContext) ACCOUNT() antlr.TerminalNode { + return s.GetToken(MySqlParserACCOUNT, 0) +} + +func (s *UserLockOptionContext) LOCK() antlr.TerminalNode { + return s.GetToken(MySqlParserLOCK, 0) +} + +func (s *UserLockOptionContext) UNLOCK() antlr.TerminalNode { + return s.GetToken(MySqlParserUNLOCK, 0) +} + +func (s *UserLockOptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UserLockOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *UserLockOptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterUserLockOption(s) + } +} + +func (s *UserLockOptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitUserLockOption(s) + } +} + +func (p *MySqlParser) UserLockOption() (localctx IUserLockOptionContext) { + localctx = NewUserLockOptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 460, MySqlParserRULE_userLockOption) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5498) + p.Match(MySqlParserACCOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5499) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*UserLockOptionContext).lockType = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserLOCK || _la == MySqlParserUNLOCK) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*UserLockOptionContext).lockType = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPrivelegeClauseContext is an interface to support dynamic dispatch. +type IPrivelegeClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Privilege() IPrivilegeContext + LR_BRACKET() antlr.TerminalNode + UidList() IUidListContext + RR_BRACKET() antlr.TerminalNode + + // IsPrivelegeClauseContext differentiates from other interfaces. + IsPrivelegeClauseContext() +} + +type PrivelegeClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPrivelegeClauseContext() *PrivelegeClauseContext { + var p = new(PrivelegeClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_privelegeClause + return p +} + +func InitEmptyPrivelegeClauseContext(p *PrivelegeClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_privelegeClause +} + +func (*PrivelegeClauseContext) IsPrivelegeClauseContext() {} + +func NewPrivelegeClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrivelegeClauseContext { + var p = new(PrivelegeClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_privelegeClause + + return p +} + +func (s *PrivelegeClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *PrivelegeClauseContext) Privilege() IPrivilegeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrivilegeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrivilegeContext) +} + +func (s *PrivelegeClauseContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *PrivelegeClauseContext) UidList() IUidListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidListContext) +} + +func (s *PrivelegeClauseContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *PrivelegeClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PrivelegeClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PrivelegeClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterPrivelegeClause(s) + } +} + +func (s *PrivelegeClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitPrivelegeClause(s) + } +} + +func (p *MySqlParser) PrivelegeClause() (localctx IPrivelegeClauseContext) { + localctx = NewPrivelegeClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 462, MySqlParserRULE_privelegeClause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5501) + p.Privilege() + } + p.SetState(5506) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserLR_BRACKET { + { + p.SetState(5502) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5503) + p.UidList() + } + { + p.SetState(5504) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPrivilegeContext is an interface to support dynamic dispatch. +type IPrivilegeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALL() antlr.TerminalNode + PRIVILEGES() antlr.TerminalNode + ALTER() antlr.TerminalNode + ROUTINE() antlr.TerminalNode + CREATE() antlr.TerminalNode + TEMPORARY() antlr.TerminalNode + TABLES() antlr.TerminalNode + VIEW() antlr.TerminalNode + USER() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + ROLE() antlr.TerminalNode + DELETE() antlr.TerminalNode + DROP() antlr.TerminalNode + EVENT() antlr.TerminalNode + EXECUTE() antlr.TerminalNode + FILE() antlr.TerminalNode + GRANT() antlr.TerminalNode + OPTION() antlr.TerminalNode + INDEX() antlr.TerminalNode + INSERT() antlr.TerminalNode + LOCK() antlr.TerminalNode + PROCESS() antlr.TerminalNode + PROXY() antlr.TerminalNode + REFERENCES() antlr.TerminalNode + RELOAD() antlr.TerminalNode + REPLICATION() antlr.TerminalNode + CLIENT() antlr.TerminalNode + SLAVE() antlr.TerminalNode + SELECT() antlr.TerminalNode + SHOW() antlr.TerminalNode + DATABASES() antlr.TerminalNode + SHUTDOWN() antlr.TerminalNode + SUPER() antlr.TerminalNode + TRIGGER() antlr.TerminalNode + UPDATE() antlr.TerminalNode + USAGE() antlr.TerminalNode + APPLICATION_PASSWORD_ADMIN() antlr.TerminalNode + AUDIT_ABORT_EXEMPT() antlr.TerminalNode + AUDIT_ADMIN() antlr.TerminalNode + AUTHENTICATION_POLICY_ADMIN() antlr.TerminalNode + BACKUP_ADMIN() antlr.TerminalNode + BINLOG_ADMIN() antlr.TerminalNode + BINLOG_ENCRYPTION_ADMIN() antlr.TerminalNode + CLONE_ADMIN() antlr.TerminalNode + CONNECTION_ADMIN() antlr.TerminalNode + ENCRYPTION_KEY_ADMIN() antlr.TerminalNode + FIREWALL_ADMIN() antlr.TerminalNode + FIREWALL_EXEMPT() antlr.TerminalNode + FIREWALL_USER() antlr.TerminalNode + FLUSH_OPTIMIZER_COSTS() antlr.TerminalNode + FLUSH_STATUS() antlr.TerminalNode + FLUSH_TABLES() antlr.TerminalNode + FLUSH_USER_RESOURCES() antlr.TerminalNode + GROUP_REPLICATION_ADMIN() antlr.TerminalNode + INNODB_REDO_LOG_ARCHIVE() antlr.TerminalNode + INNODB_REDO_LOG_ENABLE() antlr.TerminalNode + NDB_STORED_USER() antlr.TerminalNode + PASSWORDLESS_USER_ADMIN() antlr.TerminalNode + PERSIST_RO_VARIABLES_ADMIN() antlr.TerminalNode + REPLICATION_APPLIER() antlr.TerminalNode + REPLICATION_SLAVE_ADMIN() antlr.TerminalNode + RESOURCE_GROUP_ADMIN() antlr.TerminalNode + RESOURCE_GROUP_USER() antlr.TerminalNode + ROLE_ADMIN() antlr.TerminalNode + SERVICE_CONNECTION_ADMIN() antlr.TerminalNode + SESSION_VARIABLES_ADMIN() antlr.TerminalNode + SET_USER_ID() antlr.TerminalNode + SKIP_QUERY_REWRITE() antlr.TerminalNode + SHOW_ROUTINE() antlr.TerminalNode + SYSTEM_USER() antlr.TerminalNode + SYSTEM_VARIABLES_ADMIN() antlr.TerminalNode + TABLE_ENCRYPTION_ADMIN() antlr.TerminalNode + TP_CONNECTION_ADMIN() antlr.TerminalNode + VERSION_TOKEN_ADMIN() antlr.TerminalNode + XA_RECOVER_ADMIN() antlr.TerminalNode + LOAD() antlr.TerminalNode + FROM() antlr.TerminalNode + S3() antlr.TerminalNode + INTO() antlr.TerminalNode + INVOKE() antlr.TerminalNode + LAMBDA() antlr.TerminalNode + + // IsPrivilegeContext differentiates from other interfaces. + IsPrivilegeContext() +} + +type PrivilegeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPrivilegeContext() *PrivilegeContext { + var p = new(PrivilegeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_privilege + return p +} + +func InitEmptyPrivilegeContext(p *PrivilegeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_privilege +} + +func (*PrivilegeContext) IsPrivilegeContext() {} + +func NewPrivilegeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrivilegeContext { + var p = new(PrivilegeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_privilege + + return p +} + +func (s *PrivilegeContext) GetParser() antlr.Parser { return s.parser } + +func (s *PrivilegeContext) ALL() antlr.TerminalNode { + return s.GetToken(MySqlParserALL, 0) +} + +func (s *PrivilegeContext) PRIVILEGES() antlr.TerminalNode { + return s.GetToken(MySqlParserPRIVILEGES, 0) +} + +func (s *PrivilegeContext) ALTER() antlr.TerminalNode { + return s.GetToken(MySqlParserALTER, 0) +} + +func (s *PrivilegeContext) ROUTINE() antlr.TerminalNode { + return s.GetToken(MySqlParserROUTINE, 0) +} + +func (s *PrivilegeContext) CREATE() antlr.TerminalNode { + return s.GetToken(MySqlParserCREATE, 0) +} + +func (s *PrivilegeContext) TEMPORARY() antlr.TerminalNode { + return s.GetToken(MySqlParserTEMPORARY, 0) +} + +func (s *PrivilegeContext) TABLES() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLES, 0) +} + +func (s *PrivilegeContext) VIEW() antlr.TerminalNode { + return s.GetToken(MySqlParserVIEW, 0) +} + +func (s *PrivilegeContext) USER() antlr.TerminalNode { + return s.GetToken(MySqlParserUSER, 0) +} + +func (s *PrivilegeContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLESPACE, 0) +} + +func (s *PrivilegeContext) ROLE() antlr.TerminalNode { + return s.GetToken(MySqlParserROLE, 0) +} + +func (s *PrivilegeContext) DELETE() antlr.TerminalNode { + return s.GetToken(MySqlParserDELETE, 0) +} + +func (s *PrivilegeContext) DROP() antlr.TerminalNode { + return s.GetToken(MySqlParserDROP, 0) +} + +func (s *PrivilegeContext) EVENT() antlr.TerminalNode { + return s.GetToken(MySqlParserEVENT, 0) +} + +func (s *PrivilegeContext) EXECUTE() antlr.TerminalNode { + return s.GetToken(MySqlParserEXECUTE, 0) +} + +func (s *PrivilegeContext) FILE() antlr.TerminalNode { + return s.GetToken(MySqlParserFILE, 0) +} + +func (s *PrivilegeContext) GRANT() antlr.TerminalNode { + return s.GetToken(MySqlParserGRANT, 0) +} + +func (s *PrivilegeContext) OPTION() antlr.TerminalNode { + return s.GetToken(MySqlParserOPTION, 0) +} + +func (s *PrivilegeContext) INDEX() antlr.TerminalNode { + return s.GetToken(MySqlParserINDEX, 0) +} + +func (s *PrivilegeContext) INSERT() antlr.TerminalNode { + return s.GetToken(MySqlParserINSERT, 0) +} + +func (s *PrivilegeContext) LOCK() antlr.TerminalNode { + return s.GetToken(MySqlParserLOCK, 0) +} + +func (s *PrivilegeContext) PROCESS() antlr.TerminalNode { + return s.GetToken(MySqlParserPROCESS, 0) +} + +func (s *PrivilegeContext) PROXY() antlr.TerminalNode { + return s.GetToken(MySqlParserPROXY, 0) +} + +func (s *PrivilegeContext) REFERENCES() antlr.TerminalNode { + return s.GetToken(MySqlParserREFERENCES, 0) +} + +func (s *PrivilegeContext) RELOAD() antlr.TerminalNode { + return s.GetToken(MySqlParserRELOAD, 0) +} + +func (s *PrivilegeContext) REPLICATION() antlr.TerminalNode { + return s.GetToken(MySqlParserREPLICATION, 0) +} + +func (s *PrivilegeContext) CLIENT() antlr.TerminalNode { + return s.GetToken(MySqlParserCLIENT, 0) +} + +func (s *PrivilegeContext) SLAVE() antlr.TerminalNode { + return s.GetToken(MySqlParserSLAVE, 0) +} + +func (s *PrivilegeContext) SELECT() antlr.TerminalNode { + return s.GetToken(MySqlParserSELECT, 0) +} + +func (s *PrivilegeContext) SHOW() antlr.TerminalNode { + return s.GetToken(MySqlParserSHOW, 0) +} + +func (s *PrivilegeContext) DATABASES() antlr.TerminalNode { + return s.GetToken(MySqlParserDATABASES, 0) +} + +func (s *PrivilegeContext) SHUTDOWN() antlr.TerminalNode { + return s.GetToken(MySqlParserSHUTDOWN, 0) +} + +func (s *PrivilegeContext) SUPER() antlr.TerminalNode { + return s.GetToken(MySqlParserSUPER, 0) +} + +func (s *PrivilegeContext) TRIGGER() antlr.TerminalNode { + return s.GetToken(MySqlParserTRIGGER, 0) +} + +func (s *PrivilegeContext) UPDATE() antlr.TerminalNode { + return s.GetToken(MySqlParserUPDATE, 0) +} + +func (s *PrivilegeContext) USAGE() antlr.TerminalNode { + return s.GetToken(MySqlParserUSAGE, 0) +} + +func (s *PrivilegeContext) APPLICATION_PASSWORD_ADMIN() antlr.TerminalNode { + return s.GetToken(MySqlParserAPPLICATION_PASSWORD_ADMIN, 0) +} + +func (s *PrivilegeContext) AUDIT_ABORT_EXEMPT() antlr.TerminalNode { + return s.GetToken(MySqlParserAUDIT_ABORT_EXEMPT, 0) +} + +func (s *PrivilegeContext) AUDIT_ADMIN() antlr.TerminalNode { + return s.GetToken(MySqlParserAUDIT_ADMIN, 0) +} + +func (s *PrivilegeContext) AUTHENTICATION_POLICY_ADMIN() antlr.TerminalNode { + return s.GetToken(MySqlParserAUTHENTICATION_POLICY_ADMIN, 0) +} + +func (s *PrivilegeContext) BACKUP_ADMIN() antlr.TerminalNode { + return s.GetToken(MySqlParserBACKUP_ADMIN, 0) +} + +func (s *PrivilegeContext) BINLOG_ADMIN() antlr.TerminalNode { + return s.GetToken(MySqlParserBINLOG_ADMIN, 0) +} + +func (s *PrivilegeContext) BINLOG_ENCRYPTION_ADMIN() antlr.TerminalNode { + return s.GetToken(MySqlParserBINLOG_ENCRYPTION_ADMIN, 0) +} + +func (s *PrivilegeContext) CLONE_ADMIN() antlr.TerminalNode { + return s.GetToken(MySqlParserCLONE_ADMIN, 0) +} + +func (s *PrivilegeContext) CONNECTION_ADMIN() antlr.TerminalNode { + return s.GetToken(MySqlParserCONNECTION_ADMIN, 0) +} + +func (s *PrivilegeContext) ENCRYPTION_KEY_ADMIN() antlr.TerminalNode { + return s.GetToken(MySqlParserENCRYPTION_KEY_ADMIN, 0) +} + +func (s *PrivilegeContext) FIREWALL_ADMIN() antlr.TerminalNode { + return s.GetToken(MySqlParserFIREWALL_ADMIN, 0) +} + +func (s *PrivilegeContext) FIREWALL_EXEMPT() antlr.TerminalNode { + return s.GetToken(MySqlParserFIREWALL_EXEMPT, 0) +} + +func (s *PrivilegeContext) FIREWALL_USER() antlr.TerminalNode { + return s.GetToken(MySqlParserFIREWALL_USER, 0) +} + +func (s *PrivilegeContext) FLUSH_OPTIMIZER_COSTS() antlr.TerminalNode { + return s.GetToken(MySqlParserFLUSH_OPTIMIZER_COSTS, 0) +} + +func (s *PrivilegeContext) FLUSH_STATUS() antlr.TerminalNode { + return s.GetToken(MySqlParserFLUSH_STATUS, 0) +} + +func (s *PrivilegeContext) FLUSH_TABLES() antlr.TerminalNode { + return s.GetToken(MySqlParserFLUSH_TABLES, 0) +} + +func (s *PrivilegeContext) FLUSH_USER_RESOURCES() antlr.TerminalNode { + return s.GetToken(MySqlParserFLUSH_USER_RESOURCES, 0) +} + +func (s *PrivilegeContext) GROUP_REPLICATION_ADMIN() antlr.TerminalNode { + return s.GetToken(MySqlParserGROUP_REPLICATION_ADMIN, 0) +} + +func (s *PrivilegeContext) INNODB_REDO_LOG_ARCHIVE() antlr.TerminalNode { + return s.GetToken(MySqlParserINNODB_REDO_LOG_ARCHIVE, 0) +} + +func (s *PrivilegeContext) INNODB_REDO_LOG_ENABLE() antlr.TerminalNode { + return s.GetToken(MySqlParserINNODB_REDO_LOG_ENABLE, 0) +} + +func (s *PrivilegeContext) NDB_STORED_USER() antlr.TerminalNode { + return s.GetToken(MySqlParserNDB_STORED_USER, 0) +} + +func (s *PrivilegeContext) PASSWORDLESS_USER_ADMIN() antlr.TerminalNode { + return s.GetToken(MySqlParserPASSWORDLESS_USER_ADMIN, 0) +} + +func (s *PrivilegeContext) PERSIST_RO_VARIABLES_ADMIN() antlr.TerminalNode { + return s.GetToken(MySqlParserPERSIST_RO_VARIABLES_ADMIN, 0) +} + +func (s *PrivilegeContext) REPLICATION_APPLIER() antlr.TerminalNode { + return s.GetToken(MySqlParserREPLICATION_APPLIER, 0) +} + +func (s *PrivilegeContext) REPLICATION_SLAVE_ADMIN() antlr.TerminalNode { + return s.GetToken(MySqlParserREPLICATION_SLAVE_ADMIN, 0) +} + +func (s *PrivilegeContext) RESOURCE_GROUP_ADMIN() antlr.TerminalNode { + return s.GetToken(MySqlParserRESOURCE_GROUP_ADMIN, 0) +} + +func (s *PrivilegeContext) RESOURCE_GROUP_USER() antlr.TerminalNode { + return s.GetToken(MySqlParserRESOURCE_GROUP_USER, 0) +} + +func (s *PrivilegeContext) ROLE_ADMIN() antlr.TerminalNode { + return s.GetToken(MySqlParserROLE_ADMIN, 0) +} + +func (s *PrivilegeContext) SERVICE_CONNECTION_ADMIN() antlr.TerminalNode { + return s.GetToken(MySqlParserSERVICE_CONNECTION_ADMIN, 0) +} + +func (s *PrivilegeContext) SESSION_VARIABLES_ADMIN() antlr.TerminalNode { + return s.GetToken(MySqlParserSESSION_VARIABLES_ADMIN, 0) +} + +func (s *PrivilegeContext) SET_USER_ID() antlr.TerminalNode { + return s.GetToken(MySqlParserSET_USER_ID, 0) +} + +func (s *PrivilegeContext) SKIP_QUERY_REWRITE() antlr.TerminalNode { + return s.GetToken(MySqlParserSKIP_QUERY_REWRITE, 0) +} + +func (s *PrivilegeContext) SHOW_ROUTINE() antlr.TerminalNode { + return s.GetToken(MySqlParserSHOW_ROUTINE, 0) +} + +func (s *PrivilegeContext) SYSTEM_USER() antlr.TerminalNode { + return s.GetToken(MySqlParserSYSTEM_USER, 0) +} + +func (s *PrivilegeContext) SYSTEM_VARIABLES_ADMIN() antlr.TerminalNode { + return s.GetToken(MySqlParserSYSTEM_VARIABLES_ADMIN, 0) +} + +func (s *PrivilegeContext) TABLE_ENCRYPTION_ADMIN() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLE_ENCRYPTION_ADMIN, 0) +} + +func (s *PrivilegeContext) TP_CONNECTION_ADMIN() antlr.TerminalNode { + return s.GetToken(MySqlParserTP_CONNECTION_ADMIN, 0) +} + +func (s *PrivilegeContext) VERSION_TOKEN_ADMIN() antlr.TerminalNode { + return s.GetToken(MySqlParserVERSION_TOKEN_ADMIN, 0) +} + +func (s *PrivilegeContext) XA_RECOVER_ADMIN() antlr.TerminalNode { + return s.GetToken(MySqlParserXA_RECOVER_ADMIN, 0) +} + +func (s *PrivilegeContext) LOAD() antlr.TerminalNode { + return s.GetToken(MySqlParserLOAD, 0) +} + +func (s *PrivilegeContext) FROM() antlr.TerminalNode { + return s.GetToken(MySqlParserFROM, 0) +} + +func (s *PrivilegeContext) S3() antlr.TerminalNode { + return s.GetToken(MySqlParserS3, 0) +} + +func (s *PrivilegeContext) INTO() antlr.TerminalNode { + return s.GetToken(MySqlParserINTO, 0) +} + +func (s *PrivilegeContext) INVOKE() antlr.TerminalNode { + return s.GetToken(MySqlParserINVOKE, 0) +} + +func (s *PrivilegeContext) LAMBDA() antlr.TerminalNode { + return s.GetToken(MySqlParserLAMBDA, 0) +} + +func (s *PrivilegeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PrivilegeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PrivilegeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterPrivilege(s) + } +} + +func (s *PrivilegeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitPrivilege(s) + } +} + +func (p *MySqlParser) Privilege() (localctx IPrivilegeContext) { + localctx = NewPrivilegeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 464, MySqlParserRULE_privilege) + var _la int + + p.SetState(5601) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 819, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5508) + p.Match(MySqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5510) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 815, p.GetParserRuleContext()) == 1 { + { + p.SetState(5509) + p.Match(MySqlParserPRIVILEGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5512) + p.Match(MySqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5514) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 816, p.GetParserRuleContext()) == 1 { + { + p.SetState(5513) + p.Match(MySqlParserROUTINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5516) + p.Match(MySqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5524) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 817, p.GetParserRuleContext()) == 1 { + { + p.SetState(5517) + p.Match(MySqlParserTEMPORARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5518) + p.Match(MySqlParserTABLES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 817, p.GetParserRuleContext()) == 2 { + { + p.SetState(5519) + p.Match(MySqlParserROUTINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 817, p.GetParserRuleContext()) == 3 { + { + p.SetState(5520) + p.Match(MySqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 817, p.GetParserRuleContext()) == 4 { + { + p.SetState(5521) + p.Match(MySqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 817, p.GetParserRuleContext()) == 5 { + { + p.SetState(5522) + p.Match(MySqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 817, p.GetParserRuleContext()) == 6 { + { + p.SetState(5523) + p.Match(MySqlParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5526) + p.Match(MySqlParserDELETE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(5527) + p.Match(MySqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5529) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 818, p.GetParserRuleContext()) == 1 { + { + p.SetState(5528) + p.Match(MySqlParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(5531) + p.Match(MySqlParserEVENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(5532) + p.Match(MySqlParserEXECUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(5533) + p.Match(MySqlParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(5534) + p.Match(MySqlParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5535) + p.Match(MySqlParserOPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(5536) + p.Match(MySqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(5537) + p.Match(MySqlParserINSERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(5538) + p.Match(MySqlParserLOCK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5539) + p.Match(MySqlParserTABLES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(5540) + p.Match(MySqlParserPROCESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(5541) + p.Match(MySqlParserPROXY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(5542) + p.Match(MySqlParserREFERENCES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(5543) + p.Match(MySqlParserRELOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 17: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(5544) + p.Match(MySqlParserREPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5545) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserCLIENT || _la == MySqlParserSLAVE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 18: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(5546) + p.Match(MySqlParserSELECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 19: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(5547) + p.Match(MySqlParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5548) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserDATABASES || _la == MySqlParserVIEW) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 20: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(5549) + p.Match(MySqlParserSHUTDOWN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 21: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(5550) + p.Match(MySqlParserSUPER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 22: + p.EnterOuterAlt(localctx, 22) + { + p.SetState(5551) + p.Match(MySqlParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 23: + p.EnterOuterAlt(localctx, 23) + { + p.SetState(5552) + p.Match(MySqlParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 24: + p.EnterOuterAlt(localctx, 24) + { + p.SetState(5553) + p.Match(MySqlParserUSAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 25: + p.EnterOuterAlt(localctx, 25) + { + p.SetState(5554) + p.Match(MySqlParserAPPLICATION_PASSWORD_ADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 26: + p.EnterOuterAlt(localctx, 26) + { + p.SetState(5555) + p.Match(MySqlParserAUDIT_ABORT_EXEMPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 27: + p.EnterOuterAlt(localctx, 27) + { + p.SetState(5556) + p.Match(MySqlParserAUDIT_ADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 28: + p.EnterOuterAlt(localctx, 28) + { + p.SetState(5557) + p.Match(MySqlParserAUTHENTICATION_POLICY_ADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 29: + p.EnterOuterAlt(localctx, 29) + { + p.SetState(5558) + p.Match(MySqlParserBACKUP_ADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 30: + p.EnterOuterAlt(localctx, 30) + { + p.SetState(5559) + p.Match(MySqlParserBINLOG_ADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 31: + p.EnterOuterAlt(localctx, 31) + { + p.SetState(5560) + p.Match(MySqlParserBINLOG_ENCRYPTION_ADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 32: + p.EnterOuterAlt(localctx, 32) + { + p.SetState(5561) + p.Match(MySqlParserCLONE_ADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 33: + p.EnterOuterAlt(localctx, 33) + { + p.SetState(5562) + p.Match(MySqlParserCONNECTION_ADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 34: + p.EnterOuterAlt(localctx, 34) + { + p.SetState(5563) + p.Match(MySqlParserENCRYPTION_KEY_ADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 35: + p.EnterOuterAlt(localctx, 35) + { + p.SetState(5564) + p.Match(MySqlParserFIREWALL_ADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 36: + p.EnterOuterAlt(localctx, 36) + { + p.SetState(5565) + p.Match(MySqlParserFIREWALL_EXEMPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 37: + p.EnterOuterAlt(localctx, 37) + { + p.SetState(5566) + p.Match(MySqlParserFIREWALL_USER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 38: + p.EnterOuterAlt(localctx, 38) + { + p.SetState(5567) + p.Match(MySqlParserFLUSH_OPTIMIZER_COSTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 39: + p.EnterOuterAlt(localctx, 39) + { + p.SetState(5568) + p.Match(MySqlParserFLUSH_STATUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 40: + p.EnterOuterAlt(localctx, 40) + { + p.SetState(5569) + p.Match(MySqlParserFLUSH_TABLES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 41: + p.EnterOuterAlt(localctx, 41) + { + p.SetState(5570) + p.Match(MySqlParserFLUSH_USER_RESOURCES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 42: + p.EnterOuterAlt(localctx, 42) + { + p.SetState(5571) + p.Match(MySqlParserGROUP_REPLICATION_ADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 43: + p.EnterOuterAlt(localctx, 43) + { + p.SetState(5572) + p.Match(MySqlParserINNODB_REDO_LOG_ARCHIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 44: + p.EnterOuterAlt(localctx, 44) + { + p.SetState(5573) + p.Match(MySqlParserINNODB_REDO_LOG_ENABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 45: + p.EnterOuterAlt(localctx, 45) + { + p.SetState(5574) + p.Match(MySqlParserNDB_STORED_USER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 46: + p.EnterOuterAlt(localctx, 46) + { + p.SetState(5575) + p.Match(MySqlParserPASSWORDLESS_USER_ADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 47: + p.EnterOuterAlt(localctx, 47) + { + p.SetState(5576) + p.Match(MySqlParserPERSIST_RO_VARIABLES_ADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 48: + p.EnterOuterAlt(localctx, 48) + { + p.SetState(5577) + p.Match(MySqlParserREPLICATION_APPLIER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 49: + p.EnterOuterAlt(localctx, 49) + { + p.SetState(5578) + p.Match(MySqlParserREPLICATION_SLAVE_ADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 50: + p.EnterOuterAlt(localctx, 50) + { + p.SetState(5579) + p.Match(MySqlParserRESOURCE_GROUP_ADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 51: + p.EnterOuterAlt(localctx, 51) + { + p.SetState(5580) + p.Match(MySqlParserRESOURCE_GROUP_USER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 52: + p.EnterOuterAlt(localctx, 52) + { + p.SetState(5581) + p.Match(MySqlParserROLE_ADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 53: + p.EnterOuterAlt(localctx, 53) + { + p.SetState(5582) + p.Match(MySqlParserSERVICE_CONNECTION_ADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 54: + p.EnterOuterAlt(localctx, 54) + { + p.SetState(5583) + p.Match(MySqlParserSESSION_VARIABLES_ADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 55: + p.EnterOuterAlt(localctx, 55) + { + p.SetState(5584) + p.Match(MySqlParserSET_USER_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 56: + p.EnterOuterAlt(localctx, 56) + { + p.SetState(5585) + p.Match(MySqlParserSKIP_QUERY_REWRITE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 57: + p.EnterOuterAlt(localctx, 57) + { + p.SetState(5586) + p.Match(MySqlParserSHOW_ROUTINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 58: + p.EnterOuterAlt(localctx, 58) + { + p.SetState(5587) + p.Match(MySqlParserSYSTEM_USER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 59: + p.EnterOuterAlt(localctx, 59) + { + p.SetState(5588) + p.Match(MySqlParserSYSTEM_VARIABLES_ADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 60: + p.EnterOuterAlt(localctx, 60) + { + p.SetState(5589) + p.Match(MySqlParserTABLE_ENCRYPTION_ADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 61: + p.EnterOuterAlt(localctx, 61) + { + p.SetState(5590) + p.Match(MySqlParserTP_CONNECTION_ADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 62: + p.EnterOuterAlt(localctx, 62) + { + p.SetState(5591) + p.Match(MySqlParserVERSION_TOKEN_ADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 63: + p.EnterOuterAlt(localctx, 63) + { + p.SetState(5592) + p.Match(MySqlParserXA_RECOVER_ADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 64: + p.EnterOuterAlt(localctx, 64) + { + p.SetState(5593) + p.Match(MySqlParserLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5594) + p.Match(MySqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5595) + p.Match(MySqlParserS3) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 65: + p.EnterOuterAlt(localctx, 65) + { + p.SetState(5596) + p.Match(MySqlParserSELECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5597) + p.Match(MySqlParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5598) + p.Match(MySqlParserS3) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 66: + p.EnterOuterAlt(localctx, 66) + { + p.SetState(5599) + p.Match(MySqlParserINVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5600) + p.Match(MySqlParserLAMBDA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPrivilegeLevelContext is an interface to support dynamic dispatch. +type IPrivilegeLevelContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsPrivilegeLevelContext differentiates from other interfaces. + IsPrivilegeLevelContext() +} + +type PrivilegeLevelContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPrivilegeLevelContext() *PrivilegeLevelContext { + var p = new(PrivilegeLevelContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_privilegeLevel + return p +} + +func InitEmptyPrivilegeLevelContext(p *PrivilegeLevelContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_privilegeLevel +} + +func (*PrivilegeLevelContext) IsPrivilegeLevelContext() {} + +func NewPrivilegeLevelContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrivilegeLevelContext { + var p = new(PrivilegeLevelContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_privilegeLevel + + return p +} + +func (s *PrivilegeLevelContext) GetParser() antlr.Parser { return s.parser } + +func (s *PrivilegeLevelContext) CopyAll(ctx *PrivilegeLevelContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *PrivilegeLevelContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PrivilegeLevelContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type DefiniteSchemaPrivLevelContext struct { + PrivilegeLevelContext +} + +func NewDefiniteSchemaPrivLevelContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DefiniteSchemaPrivLevelContext { + var p = new(DefiniteSchemaPrivLevelContext) + + InitEmptyPrivilegeLevelContext(&p.PrivilegeLevelContext) + p.parser = parser + p.CopyAll(ctx.(*PrivilegeLevelContext)) + + return p +} + +func (s *DefiniteSchemaPrivLevelContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DefiniteSchemaPrivLevelContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *DefiniteSchemaPrivLevelContext) DOT() antlr.TerminalNode { + return s.GetToken(MySqlParserDOT, 0) +} + +func (s *DefiniteSchemaPrivLevelContext) STAR() antlr.TerminalNode { + return s.GetToken(MySqlParserSTAR, 0) +} + +func (s *DefiniteSchemaPrivLevelContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterDefiniteSchemaPrivLevel(s) + } +} + +func (s *DefiniteSchemaPrivLevelContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitDefiniteSchemaPrivLevel(s) + } +} + +type DefiniteFullTablePrivLevel2Context struct { + PrivilegeLevelContext +} + +func NewDefiniteFullTablePrivLevel2Context(parser antlr.Parser, ctx antlr.ParserRuleContext) *DefiniteFullTablePrivLevel2Context { + var p = new(DefiniteFullTablePrivLevel2Context) + + InitEmptyPrivilegeLevelContext(&p.PrivilegeLevelContext) + p.parser = parser + p.CopyAll(ctx.(*PrivilegeLevelContext)) + + return p +} + +func (s *DefiniteFullTablePrivLevel2Context) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DefiniteFullTablePrivLevel2Context) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *DefiniteFullTablePrivLevel2Context) DottedId() IDottedIdContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDottedIdContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDottedIdContext) +} + +func (s *DefiniteFullTablePrivLevel2Context) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterDefiniteFullTablePrivLevel2(s) + } +} + +func (s *DefiniteFullTablePrivLevel2Context) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitDefiniteFullTablePrivLevel2(s) + } +} + +type DefiniteFullTablePrivLevelContext struct { + PrivilegeLevelContext +} + +func NewDefiniteFullTablePrivLevelContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DefiniteFullTablePrivLevelContext { + var p = new(DefiniteFullTablePrivLevelContext) + + InitEmptyPrivilegeLevelContext(&p.PrivilegeLevelContext) + p.parser = parser + p.CopyAll(ctx.(*PrivilegeLevelContext)) + + return p +} + +func (s *DefiniteFullTablePrivLevelContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DefiniteFullTablePrivLevelContext) AllUid() []IUidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUidContext); ok { + len++ + } + } + + tst := make([]IUidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUidContext); ok { + tst[i] = t.(IUidContext) + i++ + } + } + + return tst +} + +func (s *DefiniteFullTablePrivLevelContext) Uid(i int) IUidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *DefiniteFullTablePrivLevelContext) DOT() antlr.TerminalNode { + return s.GetToken(MySqlParserDOT, 0) +} + +func (s *DefiniteFullTablePrivLevelContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterDefiniteFullTablePrivLevel(s) + } +} + +func (s *DefiniteFullTablePrivLevelContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitDefiniteFullTablePrivLevel(s) + } +} + +type GlobalPrivLevelContext struct { + PrivilegeLevelContext +} + +func NewGlobalPrivLevelContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *GlobalPrivLevelContext { + var p = new(GlobalPrivLevelContext) + + InitEmptyPrivilegeLevelContext(&p.PrivilegeLevelContext) + p.parser = parser + p.CopyAll(ctx.(*PrivilegeLevelContext)) + + return p +} + +func (s *GlobalPrivLevelContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *GlobalPrivLevelContext) AllSTAR() []antlr.TerminalNode { + return s.GetTokens(MySqlParserSTAR) +} + +func (s *GlobalPrivLevelContext) STAR(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserSTAR, i) +} + +func (s *GlobalPrivLevelContext) DOT() antlr.TerminalNode { + return s.GetToken(MySqlParserDOT, 0) +} + +func (s *GlobalPrivLevelContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterGlobalPrivLevel(s) + } +} + +func (s *GlobalPrivLevelContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitGlobalPrivLevel(s) + } +} + +type DefiniteTablePrivLevelContext struct { + PrivilegeLevelContext +} + +func NewDefiniteTablePrivLevelContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DefiniteTablePrivLevelContext { + var p = new(DefiniteTablePrivLevelContext) + + InitEmptyPrivilegeLevelContext(&p.PrivilegeLevelContext) + p.parser = parser + p.CopyAll(ctx.(*PrivilegeLevelContext)) + + return p +} + +func (s *DefiniteTablePrivLevelContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DefiniteTablePrivLevelContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *DefiniteTablePrivLevelContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterDefiniteTablePrivLevel(s) + } +} + +func (s *DefiniteTablePrivLevelContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitDefiniteTablePrivLevel(s) + } +} + +type CurrentSchemaPriviLevelContext struct { + PrivilegeLevelContext +} + +func NewCurrentSchemaPriviLevelContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CurrentSchemaPriviLevelContext { + var p = new(CurrentSchemaPriviLevelContext) + + InitEmptyPrivilegeLevelContext(&p.PrivilegeLevelContext) + p.parser = parser + p.CopyAll(ctx.(*PrivilegeLevelContext)) + + return p +} + +func (s *CurrentSchemaPriviLevelContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CurrentSchemaPriviLevelContext) STAR() antlr.TerminalNode { + return s.GetToken(MySqlParserSTAR, 0) +} + +func (s *CurrentSchemaPriviLevelContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCurrentSchemaPriviLevel(s) + } +} + +func (s *CurrentSchemaPriviLevelContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCurrentSchemaPriviLevel(s) + } +} + +func (p *MySqlParser) PrivilegeLevel() (localctx IPrivilegeLevelContext) { + localctx = NewPrivilegeLevelContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 466, MySqlParserRULE_privilegeLevel) + p.SetState(5619) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 820, p.GetParserRuleContext()) { + case 1: + localctx = NewCurrentSchemaPriviLevelContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5603) + p.Match(MySqlParserSTAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + localctx = NewGlobalPrivLevelContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5604) + p.Match(MySqlParserSTAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5605) + p.Match(MySqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5606) + p.Match(MySqlParserSTAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + localctx = NewDefiniteSchemaPrivLevelContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5607) + p.Uid() + } + { + p.SetState(5608) + p.Match(MySqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5609) + p.Match(MySqlParserSTAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + localctx = NewDefiniteFullTablePrivLevelContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5611) + p.Uid() + } + { + p.SetState(5612) + p.Match(MySqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5613) + p.Uid() + } + + case 5: + localctx = NewDefiniteFullTablePrivLevel2Context(p, localctx) + p.EnterOuterAlt(localctx, 5) + { + p.SetState(5615) + p.Uid() + } + { + p.SetState(5616) + p.DottedId() + } + + case 6: + localctx = NewDefiniteTablePrivLevelContext(p, localctx) + p.EnterOuterAlt(localctx, 6) + { + p.SetState(5618) + p.Uid() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRenameUserClauseContext is an interface to support dynamic dispatch. +type IRenameUserClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetFromFirst returns the fromFirst rule contexts. + GetFromFirst() IUserNameContext + + // GetToFirst returns the toFirst rule contexts. + GetToFirst() IUserNameContext + + // SetFromFirst sets the fromFirst rule contexts. + SetFromFirst(IUserNameContext) + + // SetToFirst sets the toFirst rule contexts. + SetToFirst(IUserNameContext) + + // Getter signatures + TO() antlr.TerminalNode + AllUserName() []IUserNameContext + UserName(i int) IUserNameContext + + // IsRenameUserClauseContext differentiates from other interfaces. + IsRenameUserClauseContext() +} + +type RenameUserClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + fromFirst IUserNameContext + toFirst IUserNameContext +} + +func NewEmptyRenameUserClauseContext() *RenameUserClauseContext { + var p = new(RenameUserClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_renameUserClause + return p +} + +func InitEmptyRenameUserClauseContext(p *RenameUserClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_renameUserClause +} + +func (*RenameUserClauseContext) IsRenameUserClauseContext() {} + +func NewRenameUserClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RenameUserClauseContext { + var p = new(RenameUserClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_renameUserClause + + return p +} + +func (s *RenameUserClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *RenameUserClauseContext) GetFromFirst() IUserNameContext { return s.fromFirst } + +func (s *RenameUserClauseContext) GetToFirst() IUserNameContext { return s.toFirst } + +func (s *RenameUserClauseContext) SetFromFirst(v IUserNameContext) { s.fromFirst = v } + +func (s *RenameUserClauseContext) SetToFirst(v IUserNameContext) { s.toFirst = v } + +func (s *RenameUserClauseContext) TO() antlr.TerminalNode { + return s.GetToken(MySqlParserTO, 0) +} + +func (s *RenameUserClauseContext) AllUserName() []IUserNameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUserNameContext); ok { + len++ + } + } + + tst := make([]IUserNameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUserNameContext); ok { + tst[i] = t.(IUserNameContext) + i++ + } + } + + return tst +} + +func (s *RenameUserClauseContext) UserName(i int) IUserNameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserNameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUserNameContext) +} + +func (s *RenameUserClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RenameUserClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RenameUserClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterRenameUserClause(s) + } +} + +func (s *RenameUserClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitRenameUserClause(s) + } +} + +func (p *MySqlParser) RenameUserClause() (localctx IRenameUserClauseContext) { + localctx = NewRenameUserClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 468, MySqlParserRULE_renameUserClause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5621) + + var _x = p.UserName() + + localctx.(*RenameUserClauseContext).fromFirst = _x + } + { + p.SetState(5622) + p.Match(MySqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5623) + + var _x = p.UserName() + + localctx.(*RenameUserClauseContext).toFirst = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAnalyzeTableContext is an interface to support dynamic dispatch. +type IAnalyzeTableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetActionOption returns the actionOption token. + GetActionOption() antlr.Token + + // SetActionOption sets the actionOption token. + SetActionOption(antlr.Token) + + // Getter signatures + ANALYZE() antlr.TerminalNode + Tables() ITablesContext + TABLE() antlr.TerminalNode + TABLES() antlr.TerminalNode + UPDATE() antlr.TerminalNode + AllHISTOGRAM() []antlr.TerminalNode + HISTOGRAM(i int) antlr.TerminalNode + AllON() []antlr.TerminalNode + ON(i int) antlr.TerminalNode + AllFullColumnName() []IFullColumnNameContext + FullColumnName(i int) IFullColumnNameContext + DROP() antlr.TerminalNode + NO_WRITE_TO_BINLOG() antlr.TerminalNode + LOCAL() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + WITH() antlr.TerminalNode + DecimalLiteral() IDecimalLiteralContext + BUCKETS() antlr.TerminalNode + + // IsAnalyzeTableContext differentiates from other interfaces. + IsAnalyzeTableContext() +} + +type AnalyzeTableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + actionOption antlr.Token +} + +func NewEmptyAnalyzeTableContext() *AnalyzeTableContext { + var p = new(AnalyzeTableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_analyzeTable + return p +} + +func InitEmptyAnalyzeTableContext(p *AnalyzeTableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_analyzeTable +} + +func (*AnalyzeTableContext) IsAnalyzeTableContext() {} + +func NewAnalyzeTableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AnalyzeTableContext { + var p = new(AnalyzeTableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_analyzeTable + + return p +} + +func (s *AnalyzeTableContext) GetParser() antlr.Parser { return s.parser } + +func (s *AnalyzeTableContext) GetActionOption() antlr.Token { return s.actionOption } + +func (s *AnalyzeTableContext) SetActionOption(v antlr.Token) { s.actionOption = v } + +func (s *AnalyzeTableContext) ANALYZE() antlr.TerminalNode { + return s.GetToken(MySqlParserANALYZE, 0) +} + +func (s *AnalyzeTableContext) Tables() ITablesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablesContext) +} + +func (s *AnalyzeTableContext) TABLE() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLE, 0) +} + +func (s *AnalyzeTableContext) TABLES() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLES, 0) +} + +func (s *AnalyzeTableContext) UPDATE() antlr.TerminalNode { + return s.GetToken(MySqlParserUPDATE, 0) +} + +func (s *AnalyzeTableContext) AllHISTOGRAM() []antlr.TerminalNode { + return s.GetTokens(MySqlParserHISTOGRAM) +} + +func (s *AnalyzeTableContext) HISTOGRAM(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserHISTOGRAM, i) +} + +func (s *AnalyzeTableContext) AllON() []antlr.TerminalNode { + return s.GetTokens(MySqlParserON) +} + +func (s *AnalyzeTableContext) ON(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserON, i) +} + +func (s *AnalyzeTableContext) AllFullColumnName() []IFullColumnNameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFullColumnNameContext); ok { + len++ + } + } + + tst := make([]IFullColumnNameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFullColumnNameContext); ok { + tst[i] = t.(IFullColumnNameContext) + i++ + } + } + + return tst +} + +func (s *AnalyzeTableContext) FullColumnName(i int) IFullColumnNameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFullColumnNameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFullColumnNameContext) +} + +func (s *AnalyzeTableContext) DROP() antlr.TerminalNode { + return s.GetToken(MySqlParserDROP, 0) +} + +func (s *AnalyzeTableContext) NO_WRITE_TO_BINLOG() antlr.TerminalNode { + return s.GetToken(MySqlParserNO_WRITE_TO_BINLOG, 0) +} + +func (s *AnalyzeTableContext) LOCAL() antlr.TerminalNode { + return s.GetToken(MySqlParserLOCAL, 0) +} + +func (s *AnalyzeTableContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *AnalyzeTableContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *AnalyzeTableContext) WITH() antlr.TerminalNode { + return s.GetToken(MySqlParserWITH, 0) +} + +func (s *AnalyzeTableContext) DecimalLiteral() IDecimalLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *AnalyzeTableContext) BUCKETS() antlr.TerminalNode { + return s.GetToken(MySqlParserBUCKETS, 0) +} + +func (s *AnalyzeTableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AnalyzeTableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AnalyzeTableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAnalyzeTable(s) + } +} + +func (s *AnalyzeTableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAnalyzeTable(s) + } +} + +func (p *MySqlParser) AnalyzeTable() (localctx IAnalyzeTableContext) { + localctx = NewAnalyzeTableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 470, MySqlParserRULE_analyzeTable) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5625) + p.Match(MySqlParserANALYZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5627) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserNO_WRITE_TO_BINLOG || _la == MySqlParserLOCAL { + { + p.SetState(5626) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*AnalyzeTableContext).actionOption = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserNO_WRITE_TO_BINLOG || _la == MySqlParserLOCAL) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*AnalyzeTableContext).actionOption = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(5629) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserTABLE || _la == MySqlParserTABLES) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(5630) + p.Tables() + } + p.SetState(5648) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 824, p.GetParserRuleContext()) == 1 { + { + p.SetState(5631) + p.Match(MySqlParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5632) + p.Match(MySqlParserHISTOGRAM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5633) + p.Match(MySqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5634) + p.FullColumnName() + } + p.SetState(5639) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(5635) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5636) + p.FullColumnName() + } + + p.SetState(5641) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(5646) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 823, p.GetParserRuleContext()) == 1 { + { + p.SetState(5642) + p.Match(MySqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5643) + p.DecimalLiteral() + } + { + p.SetState(5644) + p.Match(MySqlParserBUCKETS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5661) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 826, p.GetParserRuleContext()) == 1 { + { + p.SetState(5650) + p.Match(MySqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5651) + p.Match(MySqlParserHISTOGRAM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5652) + p.Match(MySqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5653) + p.FullColumnName() + } + p.SetState(5658) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(5654) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5655) + p.FullColumnName() + } + + p.SetState(5660) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICheckTableContext is an interface to support dynamic dispatch. +type ICheckTableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHECK() antlr.TerminalNode + TABLE() antlr.TerminalNode + Tables() ITablesContext + AllCheckTableOption() []ICheckTableOptionContext + CheckTableOption(i int) ICheckTableOptionContext + + // IsCheckTableContext differentiates from other interfaces. + IsCheckTableContext() +} + +type CheckTableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCheckTableContext() *CheckTableContext { + var p = new(CheckTableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_checkTable + return p +} + +func InitEmptyCheckTableContext(p *CheckTableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_checkTable +} + +func (*CheckTableContext) IsCheckTableContext() {} + +func NewCheckTableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CheckTableContext { + var p = new(CheckTableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_checkTable + + return p +} + +func (s *CheckTableContext) GetParser() antlr.Parser { return s.parser } + +func (s *CheckTableContext) CHECK() antlr.TerminalNode { + return s.GetToken(MySqlParserCHECK, 0) +} + +func (s *CheckTableContext) TABLE() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLE, 0) +} + +func (s *CheckTableContext) Tables() ITablesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablesContext) +} + +func (s *CheckTableContext) AllCheckTableOption() []ICheckTableOptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICheckTableOptionContext); ok { + len++ + } + } + + tst := make([]ICheckTableOptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICheckTableOptionContext); ok { + tst[i] = t.(ICheckTableOptionContext) + i++ + } + } + + return tst +} + +func (s *CheckTableContext) CheckTableOption(i int) ICheckTableOptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICheckTableOptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICheckTableOptionContext) +} + +func (s *CheckTableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CheckTableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CheckTableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCheckTable(s) + } +} + +func (s *CheckTableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCheckTable(s) + } +} + +func (p *MySqlParser) CheckTable() (localctx ICheckTableContext) { + localctx = NewCheckTableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 472, MySqlParserRULE_checkTable) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5663) + p.Match(MySqlParserCHECK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5664) + p.Match(MySqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5665) + p.Tables() + } + p.SetState(5669) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserFOR || _la == MySqlParserCHANGED || _la == MySqlParserEXTENDED || _la == MySqlParserFAST || _la == MySqlParserMEDIUM || _la == MySqlParserQUICK { + { + p.SetState(5666) + p.CheckTableOption() + } + + p.SetState(5671) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IChecksumTableContext is an interface to support dynamic dispatch. +type IChecksumTableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetActionOption returns the actionOption token. + GetActionOption() antlr.Token + + // SetActionOption sets the actionOption token. + SetActionOption(antlr.Token) + + // Getter signatures + CHECKSUM() antlr.TerminalNode + TABLE() antlr.TerminalNode + Tables() ITablesContext + QUICK() antlr.TerminalNode + EXTENDED() antlr.TerminalNode + + // IsChecksumTableContext differentiates from other interfaces. + IsChecksumTableContext() +} + +type ChecksumTableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + actionOption antlr.Token +} + +func NewEmptyChecksumTableContext() *ChecksumTableContext { + var p = new(ChecksumTableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_checksumTable + return p +} + +func InitEmptyChecksumTableContext(p *ChecksumTableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_checksumTable +} + +func (*ChecksumTableContext) IsChecksumTableContext() {} + +func NewChecksumTableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ChecksumTableContext { + var p = new(ChecksumTableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_checksumTable + + return p +} + +func (s *ChecksumTableContext) GetParser() antlr.Parser { return s.parser } + +func (s *ChecksumTableContext) GetActionOption() antlr.Token { return s.actionOption } + +func (s *ChecksumTableContext) SetActionOption(v antlr.Token) { s.actionOption = v } + +func (s *ChecksumTableContext) CHECKSUM() antlr.TerminalNode { + return s.GetToken(MySqlParserCHECKSUM, 0) +} + +func (s *ChecksumTableContext) TABLE() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLE, 0) +} + +func (s *ChecksumTableContext) Tables() ITablesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablesContext) +} + +func (s *ChecksumTableContext) QUICK() antlr.TerminalNode { + return s.GetToken(MySqlParserQUICK, 0) +} + +func (s *ChecksumTableContext) EXTENDED() antlr.TerminalNode { + return s.GetToken(MySqlParserEXTENDED, 0) +} + +func (s *ChecksumTableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ChecksumTableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ChecksumTableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterChecksumTable(s) + } +} + +func (s *ChecksumTableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitChecksumTable(s) + } +} + +func (p *MySqlParser) ChecksumTable() (localctx IChecksumTableContext) { + localctx = NewChecksumTableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 474, MySqlParserRULE_checksumTable) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5672) + p.Match(MySqlParserCHECKSUM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5673) + p.Match(MySqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5674) + p.Tables() + } + p.SetState(5676) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEXTENDED || _la == MySqlParserQUICK { + { + p.SetState(5675) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*ChecksumTableContext).actionOption = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserEXTENDED || _la == MySqlParserQUICK) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*ChecksumTableContext).actionOption = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOptimizeTableContext is an interface to support dynamic dispatch. +type IOptimizeTableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetActionOption returns the actionOption token. + GetActionOption() antlr.Token + + // SetActionOption sets the actionOption token. + SetActionOption(antlr.Token) + + // Getter signatures + OPTIMIZE() antlr.TerminalNode + Tables() ITablesContext + TABLE() antlr.TerminalNode + TABLES() antlr.TerminalNode + NO_WRITE_TO_BINLOG() antlr.TerminalNode + LOCAL() antlr.TerminalNode + + // IsOptimizeTableContext differentiates from other interfaces. + IsOptimizeTableContext() +} + +type OptimizeTableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + actionOption antlr.Token +} + +func NewEmptyOptimizeTableContext() *OptimizeTableContext { + var p = new(OptimizeTableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_optimizeTable + return p +} + +func InitEmptyOptimizeTableContext(p *OptimizeTableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_optimizeTable +} + +func (*OptimizeTableContext) IsOptimizeTableContext() {} + +func NewOptimizeTableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptimizeTableContext { + var p = new(OptimizeTableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_optimizeTable + + return p +} + +func (s *OptimizeTableContext) GetParser() antlr.Parser { return s.parser } + +func (s *OptimizeTableContext) GetActionOption() antlr.Token { return s.actionOption } + +func (s *OptimizeTableContext) SetActionOption(v antlr.Token) { s.actionOption = v } + +func (s *OptimizeTableContext) OPTIMIZE() antlr.TerminalNode { + return s.GetToken(MySqlParserOPTIMIZE, 0) +} + +func (s *OptimizeTableContext) Tables() ITablesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablesContext) +} + +func (s *OptimizeTableContext) TABLE() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLE, 0) +} + +func (s *OptimizeTableContext) TABLES() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLES, 0) +} + +func (s *OptimizeTableContext) NO_WRITE_TO_BINLOG() antlr.TerminalNode { + return s.GetToken(MySqlParserNO_WRITE_TO_BINLOG, 0) +} + +func (s *OptimizeTableContext) LOCAL() antlr.TerminalNode { + return s.GetToken(MySqlParserLOCAL, 0) +} + +func (s *OptimizeTableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *OptimizeTableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *OptimizeTableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterOptimizeTable(s) + } +} + +func (s *OptimizeTableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitOptimizeTable(s) + } +} + +func (p *MySqlParser) OptimizeTable() (localctx IOptimizeTableContext) { + localctx = NewOptimizeTableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 476, MySqlParserRULE_optimizeTable) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5678) + p.Match(MySqlParserOPTIMIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5680) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserNO_WRITE_TO_BINLOG || _la == MySqlParserLOCAL { + { + p.SetState(5679) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*OptimizeTableContext).actionOption = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserNO_WRITE_TO_BINLOG || _la == MySqlParserLOCAL) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*OptimizeTableContext).actionOption = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(5682) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserTABLE || _la == MySqlParserTABLES) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(5683) + p.Tables() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRepairTableContext is an interface to support dynamic dispatch. +type IRepairTableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetActionOption returns the actionOption token. + GetActionOption() antlr.Token + + // SetActionOption sets the actionOption token. + SetActionOption(antlr.Token) + + // Getter signatures + REPAIR() antlr.TerminalNode + TABLE() antlr.TerminalNode + Tables() ITablesContext + QUICK() antlr.TerminalNode + EXTENDED() antlr.TerminalNode + USE_FRM() antlr.TerminalNode + NO_WRITE_TO_BINLOG() antlr.TerminalNode + LOCAL() antlr.TerminalNode + + // IsRepairTableContext differentiates from other interfaces. + IsRepairTableContext() +} + +type RepairTableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + actionOption antlr.Token +} + +func NewEmptyRepairTableContext() *RepairTableContext { + var p = new(RepairTableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_repairTable + return p +} + +func InitEmptyRepairTableContext(p *RepairTableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_repairTable +} + +func (*RepairTableContext) IsRepairTableContext() {} + +func NewRepairTableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RepairTableContext { + var p = new(RepairTableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_repairTable + + return p +} + +func (s *RepairTableContext) GetParser() antlr.Parser { return s.parser } + +func (s *RepairTableContext) GetActionOption() antlr.Token { return s.actionOption } + +func (s *RepairTableContext) SetActionOption(v antlr.Token) { s.actionOption = v } + +func (s *RepairTableContext) REPAIR() antlr.TerminalNode { + return s.GetToken(MySqlParserREPAIR, 0) +} + +func (s *RepairTableContext) TABLE() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLE, 0) +} + +func (s *RepairTableContext) Tables() ITablesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablesContext) +} + +func (s *RepairTableContext) QUICK() antlr.TerminalNode { + return s.GetToken(MySqlParserQUICK, 0) +} + +func (s *RepairTableContext) EXTENDED() antlr.TerminalNode { + return s.GetToken(MySqlParserEXTENDED, 0) +} + +func (s *RepairTableContext) USE_FRM() antlr.TerminalNode { + return s.GetToken(MySqlParserUSE_FRM, 0) +} + +func (s *RepairTableContext) NO_WRITE_TO_BINLOG() antlr.TerminalNode { + return s.GetToken(MySqlParserNO_WRITE_TO_BINLOG, 0) +} + +func (s *RepairTableContext) LOCAL() antlr.TerminalNode { + return s.GetToken(MySqlParserLOCAL, 0) +} + +func (s *RepairTableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RepairTableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RepairTableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterRepairTable(s) + } +} + +func (s *RepairTableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitRepairTable(s) + } +} + +func (p *MySqlParser) RepairTable() (localctx IRepairTableContext) { + localctx = NewRepairTableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 478, MySqlParserRULE_repairTable) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5685) + p.Match(MySqlParserREPAIR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5687) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserNO_WRITE_TO_BINLOG || _la == MySqlParserLOCAL { + { + p.SetState(5686) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*RepairTableContext).actionOption = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserNO_WRITE_TO_BINLOG || _la == MySqlParserLOCAL) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*RepairTableContext).actionOption = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(5689) + p.Match(MySqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5690) + p.Tables() + } + p.SetState(5692) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserQUICK { + { + p.SetState(5691) + p.Match(MySqlParserQUICK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(5695) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEXTENDED { + { + p.SetState(5694) + p.Match(MySqlParserEXTENDED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(5698) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserUSE_FRM { + { + p.SetState(5697) + p.Match(MySqlParserUSE_FRM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICheckTableOptionContext is an interface to support dynamic dispatch. +type ICheckTableOptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FOR() antlr.TerminalNode + UPGRADE() antlr.TerminalNode + QUICK() antlr.TerminalNode + FAST() antlr.TerminalNode + MEDIUM() antlr.TerminalNode + EXTENDED() antlr.TerminalNode + CHANGED() antlr.TerminalNode + + // IsCheckTableOptionContext differentiates from other interfaces. + IsCheckTableOptionContext() +} + +type CheckTableOptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCheckTableOptionContext() *CheckTableOptionContext { + var p = new(CheckTableOptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_checkTableOption + return p +} + +func InitEmptyCheckTableOptionContext(p *CheckTableOptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_checkTableOption +} + +func (*CheckTableOptionContext) IsCheckTableOptionContext() {} + +func NewCheckTableOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CheckTableOptionContext { + var p = new(CheckTableOptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_checkTableOption + + return p +} + +func (s *CheckTableOptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *CheckTableOptionContext) FOR() antlr.TerminalNode { + return s.GetToken(MySqlParserFOR, 0) +} + +func (s *CheckTableOptionContext) UPGRADE() antlr.TerminalNode { + return s.GetToken(MySqlParserUPGRADE, 0) +} + +func (s *CheckTableOptionContext) QUICK() antlr.TerminalNode { + return s.GetToken(MySqlParserQUICK, 0) +} + +func (s *CheckTableOptionContext) FAST() antlr.TerminalNode { + return s.GetToken(MySqlParserFAST, 0) +} + +func (s *CheckTableOptionContext) MEDIUM() antlr.TerminalNode { + return s.GetToken(MySqlParserMEDIUM, 0) +} + +func (s *CheckTableOptionContext) EXTENDED() antlr.TerminalNode { + return s.GetToken(MySqlParserEXTENDED, 0) +} + +func (s *CheckTableOptionContext) CHANGED() antlr.TerminalNode { + return s.GetToken(MySqlParserCHANGED, 0) +} + +func (s *CheckTableOptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CheckTableOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CheckTableOptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCheckTableOption(s) + } +} + +func (s *CheckTableOptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCheckTableOption(s) + } +} + +func (p *MySqlParser) CheckTableOption() (localctx ICheckTableOptionContext) { + localctx = NewCheckTableOptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 480, MySqlParserRULE_checkTableOption) + p.SetState(5707) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserFOR: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5700) + p.Match(MySqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5701) + p.Match(MySqlParserUPGRADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserQUICK: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5702) + p.Match(MySqlParserQUICK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserFAST: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5703) + p.Match(MySqlParserFAST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserMEDIUM: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5704) + p.Match(MySqlParserMEDIUM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserEXTENDED: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(5705) + p.Match(MySqlParserEXTENDED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserCHANGED: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(5706) + p.Match(MySqlParserCHANGED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreateUdfunctionContext is an interface to support dynamic dispatch. +type ICreateUdfunctionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetReturnType returns the returnType token. + GetReturnType() antlr.Token + + // SetReturnType sets the returnType token. + SetReturnType(antlr.Token) + + // Getter signatures + CREATE() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + Uid() IUidContext + RETURNS() antlr.TerminalNode + SONAME() antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + STRING() antlr.TerminalNode + INTEGER() antlr.TerminalNode + REAL() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + AGGREGATE() antlr.TerminalNode + IfNotExists() IIfNotExistsContext + + // IsCreateUdfunctionContext differentiates from other interfaces. + IsCreateUdfunctionContext() +} + +type CreateUdfunctionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + returnType antlr.Token +} + +func NewEmptyCreateUdfunctionContext() *CreateUdfunctionContext { + var p = new(CreateUdfunctionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_createUdfunction + return p +} + +func InitEmptyCreateUdfunctionContext(p *CreateUdfunctionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_createUdfunction +} + +func (*CreateUdfunctionContext) IsCreateUdfunctionContext() {} + +func NewCreateUdfunctionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateUdfunctionContext { + var p = new(CreateUdfunctionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_createUdfunction + + return p +} + +func (s *CreateUdfunctionContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateUdfunctionContext) GetReturnType() antlr.Token { return s.returnType } + +func (s *CreateUdfunctionContext) SetReturnType(v antlr.Token) { s.returnType = v } + +func (s *CreateUdfunctionContext) CREATE() antlr.TerminalNode { + return s.GetToken(MySqlParserCREATE, 0) +} + +func (s *CreateUdfunctionContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(MySqlParserFUNCTION, 0) +} + +func (s *CreateUdfunctionContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *CreateUdfunctionContext) RETURNS() antlr.TerminalNode { + return s.GetToken(MySqlParserRETURNS, 0) +} + +func (s *CreateUdfunctionContext) SONAME() antlr.TerminalNode { + return s.GetToken(MySqlParserSONAME, 0) +} + +func (s *CreateUdfunctionContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *CreateUdfunctionContext) STRING() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING, 0) +} + +func (s *CreateUdfunctionContext) INTEGER() antlr.TerminalNode { + return s.GetToken(MySqlParserINTEGER, 0) +} + +func (s *CreateUdfunctionContext) REAL() antlr.TerminalNode { + return s.GetToken(MySqlParserREAL, 0) +} + +func (s *CreateUdfunctionContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(MySqlParserDECIMAL, 0) +} + +func (s *CreateUdfunctionContext) AGGREGATE() antlr.TerminalNode { + return s.GetToken(MySqlParserAGGREGATE, 0) +} + +func (s *CreateUdfunctionContext) IfNotExists() IIfNotExistsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfNotExistsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfNotExistsContext) +} + +func (s *CreateUdfunctionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateUdfunctionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateUdfunctionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCreateUdfunction(s) + } +} + +func (s *CreateUdfunctionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCreateUdfunction(s) + } +} + +func (p *MySqlParser) CreateUdfunction() (localctx ICreateUdfunctionContext) { + localctx = NewCreateUdfunctionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 482, MySqlParserRULE_createUdfunction) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5709) + p.Match(MySqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5711) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserAGGREGATE { + { + p.SetState(5710) + p.Match(MySqlParserAGGREGATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5713) + p.Match(MySqlParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5715) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 836, p.GetParserRuleContext()) == 1 { + { + p.SetState(5714) + p.IfNotExists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5717) + p.Uid() + } + { + p.SetState(5718) + p.Match(MySqlParserRETURNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5719) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*CreateUdfunctionContext).returnType = _lt + + _la = p.GetTokenStream().LA(1) + + if !(((int64((_la-206)) & ^0x3f) == 0 && ((int64(1)<<(_la-206))&261) != 0) || _la == MySqlParserSTRING) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*CreateUdfunctionContext).returnType = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(5720) + p.Match(MySqlParserSONAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5721) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInstallPluginContext is an interface to support dynamic dispatch. +type IInstallPluginContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INSTALL() antlr.TerminalNode + PLUGIN() antlr.TerminalNode + Uid() IUidContext + SONAME() antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + + // IsInstallPluginContext differentiates from other interfaces. + IsInstallPluginContext() +} + +type InstallPluginContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInstallPluginContext() *InstallPluginContext { + var p = new(InstallPluginContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_installPlugin + return p +} + +func InitEmptyInstallPluginContext(p *InstallPluginContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_installPlugin +} + +func (*InstallPluginContext) IsInstallPluginContext() {} + +func NewInstallPluginContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InstallPluginContext { + var p = new(InstallPluginContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_installPlugin + + return p +} + +func (s *InstallPluginContext) GetParser() antlr.Parser { return s.parser } + +func (s *InstallPluginContext) INSTALL() antlr.TerminalNode { + return s.GetToken(MySqlParserINSTALL, 0) +} + +func (s *InstallPluginContext) PLUGIN() antlr.TerminalNode { + return s.GetToken(MySqlParserPLUGIN, 0) +} + +func (s *InstallPluginContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *InstallPluginContext) SONAME() antlr.TerminalNode { + return s.GetToken(MySqlParserSONAME, 0) +} + +func (s *InstallPluginContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *InstallPluginContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *InstallPluginContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *InstallPluginContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterInstallPlugin(s) + } +} + +func (s *InstallPluginContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitInstallPlugin(s) + } +} + +func (p *MySqlParser) InstallPlugin() (localctx IInstallPluginContext) { + localctx = NewInstallPluginContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 484, MySqlParserRULE_installPlugin) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5723) + p.Match(MySqlParserINSTALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5724) + p.Match(MySqlParserPLUGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5725) + p.Uid() + } + { + p.SetState(5726) + p.Match(MySqlParserSONAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5727) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUninstallPluginContext is an interface to support dynamic dispatch. +type IUninstallPluginContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNINSTALL() antlr.TerminalNode + PLUGIN() antlr.TerminalNode + Uid() IUidContext + + // IsUninstallPluginContext differentiates from other interfaces. + IsUninstallPluginContext() +} + +type UninstallPluginContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUninstallPluginContext() *UninstallPluginContext { + var p = new(UninstallPluginContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_uninstallPlugin + return p +} + +func InitEmptyUninstallPluginContext(p *UninstallPluginContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_uninstallPlugin +} + +func (*UninstallPluginContext) IsUninstallPluginContext() {} + +func NewUninstallPluginContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UninstallPluginContext { + var p = new(UninstallPluginContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_uninstallPlugin + + return p +} + +func (s *UninstallPluginContext) GetParser() antlr.Parser { return s.parser } + +func (s *UninstallPluginContext) UNINSTALL() antlr.TerminalNode { + return s.GetToken(MySqlParserUNINSTALL, 0) +} + +func (s *UninstallPluginContext) PLUGIN() antlr.TerminalNode { + return s.GetToken(MySqlParserPLUGIN, 0) +} + +func (s *UninstallPluginContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *UninstallPluginContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UninstallPluginContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *UninstallPluginContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterUninstallPlugin(s) + } +} + +func (s *UninstallPluginContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitUninstallPlugin(s) + } +} + +func (p *MySqlParser) UninstallPlugin() (localctx IUninstallPluginContext) { + localctx = NewUninstallPluginContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 486, MySqlParserRULE_uninstallPlugin) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5729) + p.Match(MySqlParserUNINSTALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5730) + p.Match(MySqlParserPLUGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5731) + p.Uid() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISetStatementContext is an interface to support dynamic dispatch. +type ISetStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsSetStatementContext differentiates from other interfaces. + IsSetStatementContext() +} + +type SetStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySetStatementContext() *SetStatementContext { + var p = new(SetStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_setStatement + return p +} + +func InitEmptySetStatementContext(p *SetStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_setStatement +} + +func (*SetStatementContext) IsSetStatementContext() {} + +func NewSetStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SetStatementContext { + var p = new(SetStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_setStatement + + return p +} + +func (s *SetStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *SetStatementContext) CopyAll(ctx *SetStatementContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *SetStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SetStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type SetTransactionContext struct { + SetStatementContext +} + +func NewSetTransactionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SetTransactionContext { + var p = new(SetTransactionContext) + + InitEmptySetStatementContext(&p.SetStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SetStatementContext)) + + return p +} + +func (s *SetTransactionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SetTransactionContext) SetTransactionStatement() ISetTransactionStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISetTransactionStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISetTransactionStatementContext) +} + +func (s *SetTransactionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSetTransaction(s) + } +} + +func (s *SetTransactionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSetTransaction(s) + } +} + +type SetCharsetContext struct { + SetStatementContext +} + +func NewSetCharsetContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SetCharsetContext { + var p = new(SetCharsetContext) + + InitEmptySetStatementContext(&p.SetStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SetStatementContext)) + + return p +} + +func (s *SetCharsetContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SetCharsetContext) SET() antlr.TerminalNode { + return s.GetToken(MySqlParserSET, 0) +} + +func (s *SetCharsetContext) CharSet() ICharSetContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICharSetContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICharSetContext) +} + +func (s *SetCharsetContext) CharsetName() ICharsetNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICharsetNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICharsetNameContext) +} + +func (s *SetCharsetContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(MySqlParserDEFAULT, 0) +} + +func (s *SetCharsetContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSetCharset(s) + } +} + +func (s *SetCharsetContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSetCharset(s) + } +} + +type SetNamesContext struct { + SetStatementContext +} + +func NewSetNamesContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SetNamesContext { + var p = new(SetNamesContext) + + InitEmptySetStatementContext(&p.SetStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SetStatementContext)) + + return p +} + +func (s *SetNamesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SetNamesContext) SET() antlr.TerminalNode { + return s.GetToken(MySqlParserSET, 0) +} + +func (s *SetNamesContext) NAMES() antlr.TerminalNode { + return s.GetToken(MySqlParserNAMES, 0) +} + +func (s *SetNamesContext) CharsetName() ICharsetNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICharsetNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICharsetNameContext) +} + +func (s *SetNamesContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(MySqlParserDEFAULT, 0) +} + +func (s *SetNamesContext) COLLATE() antlr.TerminalNode { + return s.GetToken(MySqlParserCOLLATE, 0) +} + +func (s *SetNamesContext) CollationName() ICollationNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICollationNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICollationNameContext) +} + +func (s *SetNamesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSetNames(s) + } +} + +func (s *SetNamesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSetNames(s) + } +} + +type SetPasswordContext struct { + SetStatementContext +} + +func NewSetPasswordContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SetPasswordContext { + var p = new(SetPasswordContext) + + InitEmptySetStatementContext(&p.SetStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SetStatementContext)) + + return p +} + +func (s *SetPasswordContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SetPasswordContext) SetPasswordStatement() ISetPasswordStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISetPasswordStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISetPasswordStatementContext) +} + +func (s *SetPasswordContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSetPassword(s) + } +} + +func (s *SetPasswordContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSetPassword(s) + } +} + +type SetAutocommitContext struct { + SetStatementContext +} + +func NewSetAutocommitContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SetAutocommitContext { + var p = new(SetAutocommitContext) + + InitEmptySetStatementContext(&p.SetStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SetStatementContext)) + + return p +} + +func (s *SetAutocommitContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SetAutocommitContext) SetAutocommitStatement() ISetAutocommitStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISetAutocommitStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISetAutocommitStatementContext) +} + +func (s *SetAutocommitContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSetAutocommit(s) + } +} + +func (s *SetAutocommitContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSetAutocommit(s) + } +} + +type SetNewValueInsideTriggerContext struct { + SetStatementContext +} + +func NewSetNewValueInsideTriggerContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SetNewValueInsideTriggerContext { + var p = new(SetNewValueInsideTriggerContext) + + InitEmptySetStatementContext(&p.SetStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SetStatementContext)) + + return p +} + +func (s *SetNewValueInsideTriggerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SetNewValueInsideTriggerContext) SET() antlr.TerminalNode { + return s.GetToken(MySqlParserSET, 0) +} + +func (s *SetNewValueInsideTriggerContext) AllFullId() []IFullIdContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFullIdContext); ok { + len++ + } + } + + tst := make([]IFullIdContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFullIdContext); ok { + tst[i] = t.(IFullIdContext) + i++ + } + } + + return tst +} + +func (s *SetNewValueInsideTriggerContext) FullId(i int) IFullIdContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFullIdContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFullIdContext) +} + +func (s *SetNewValueInsideTriggerContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *SetNewValueInsideTriggerContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *SetNewValueInsideTriggerContext) AllEQUAL_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(MySqlParserEQUAL_SYMBOL) +} + +func (s *SetNewValueInsideTriggerContext) EQUAL_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, i) +} + +func (s *SetNewValueInsideTriggerContext) AllVAR_ASSIGN() []antlr.TerminalNode { + return s.GetTokens(MySqlParserVAR_ASSIGN) +} + +func (s *SetNewValueInsideTriggerContext) VAR_ASSIGN(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserVAR_ASSIGN, i) +} + +func (s *SetNewValueInsideTriggerContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *SetNewValueInsideTriggerContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *SetNewValueInsideTriggerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSetNewValueInsideTrigger(s) + } +} + +func (s *SetNewValueInsideTriggerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSetNewValueInsideTrigger(s) + } +} + +type SetVariableContext struct { + SetStatementContext +} + +func NewSetVariableContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SetVariableContext { + var p = new(SetVariableContext) + + InitEmptySetStatementContext(&p.SetStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SetStatementContext)) + + return p +} + +func (s *SetVariableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SetVariableContext) SET() antlr.TerminalNode { + return s.GetToken(MySqlParserSET, 0) +} + +func (s *SetVariableContext) AllVariableClause() []IVariableClauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IVariableClauseContext); ok { + len++ + } + } + + tst := make([]IVariableClauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IVariableClauseContext); ok { + tst[i] = t.(IVariableClauseContext) + i++ + } + } + + return tst +} + +func (s *SetVariableContext) VariableClause(i int) IVariableClauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVariableClauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IVariableClauseContext) +} + +func (s *SetVariableContext) AllEQUAL_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(MySqlParserEQUAL_SYMBOL) +} + +func (s *SetVariableContext) EQUAL_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, i) +} + +func (s *SetVariableContext) AllVAR_ASSIGN() []antlr.TerminalNode { + return s.GetTokens(MySqlParserVAR_ASSIGN) +} + +func (s *SetVariableContext) VAR_ASSIGN(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserVAR_ASSIGN, i) +} + +func (s *SetVariableContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *SetVariableContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *SetVariableContext) AllON() []antlr.TerminalNode { + return s.GetTokens(MySqlParserON) +} + +func (s *SetVariableContext) ON(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserON, i) +} + +func (s *SetVariableContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *SetVariableContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *SetVariableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSetVariable(s) + } +} + +func (s *SetVariableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSetVariable(s) + } +} + +func (p *MySqlParser) SetStatement() (localctx ISetStatementContext) { + localctx = NewSetStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 488, MySqlParserRULE_setStatement) + var _la int + + p.SetState(5785) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 844, p.GetParserRuleContext()) { + case 1: + localctx = NewSetVariableContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5733) + p.Match(MySqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5734) + p.VariableClause() + } + { + p.SetState(5735) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserVAR_ASSIGN || _la == MySqlParserEQUAL_SYMBOL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(5738) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 837, p.GetParserRuleContext()) { + case 1: + { + p.SetState(5736) + p.expression(0) + } + + case 2: + { + p.SetState(5737) + p.Match(MySqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(5749) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(5740) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5741) + p.VariableClause() + } + { + p.SetState(5742) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserVAR_ASSIGN || _la == MySqlParserEQUAL_SYMBOL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(5745) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 838, p.GetParserRuleContext()) { + case 1: + { + p.SetState(5743) + p.expression(0) + } + + case 2: + { + p.SetState(5744) + p.Match(MySqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(5751) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 2: + localctx = NewSetCharsetContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5752) + p.Match(MySqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5753) + p.CharSet() + } + p.SetState(5756) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserBINARY, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserCHARSET_REVERSE_QOUTE_STRING, MySqlParserSTRING_LITERAL: + { + p.SetState(5754) + p.CharsetName() + } + + case MySqlParserDEFAULT: + { + p.SetState(5755) + p.Match(MySqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 3: + localctx = NewSetNamesContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5758) + p.Match(MySqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5759) + p.Match(MySqlParserNAMES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5766) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserBINARY, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserCHARSET_REVERSE_QOUTE_STRING, MySqlParserSTRING_LITERAL: + { + p.SetState(5760) + p.CharsetName() + } + p.SetState(5763) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserCOLLATE { + { + p.SetState(5761) + p.Match(MySqlParserCOLLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5762) + p.CollationName() + } + + } + + case MySqlParserDEFAULT: + { + p.SetState(5765) + p.Match(MySqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 4: + localctx = NewSetPasswordContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5768) + p.SetPasswordStatement() + } + + case 5: + localctx = NewSetTransactionContext(p, localctx) + p.EnterOuterAlt(localctx, 5) + { + p.SetState(5769) + p.SetTransactionStatement() + } + + case 6: + localctx = NewSetAutocommitContext(p, localctx) + p.EnterOuterAlt(localctx, 6) + { + p.SetState(5770) + p.SetAutocommitStatement() + } + + case 7: + localctx = NewSetNewValueInsideTriggerContext(p, localctx) + p.EnterOuterAlt(localctx, 7) + { + p.SetState(5771) + p.Match(MySqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5772) + p.FullId() + } + { + p.SetState(5773) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserVAR_ASSIGN || _la == MySqlParserEQUAL_SYMBOL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(5774) + p.expression(0) + } + p.SetState(5782) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(5775) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5776) + p.FullId() + } + { + p.SetState(5777) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserVAR_ASSIGN || _la == MySqlParserEQUAL_SYMBOL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(5778) + p.expression(0) + } + + p.SetState(5784) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShowStatementContext is an interface to support dynamic dispatch. +type IShowStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsShowStatementContext differentiates from other interfaces. + IsShowStatementContext() +} + +type ShowStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShowStatementContext() *ShowStatementContext { + var p = new(ShowStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_showStatement + return p +} + +func InitEmptyShowStatementContext(p *ShowStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_showStatement +} + +func (*ShowStatementContext) IsShowStatementContext() {} + +func NewShowStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ShowStatementContext { + var p = new(ShowStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_showStatement + + return p +} + +func (s *ShowStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *ShowStatementContext) CopyAll(ctx *ShowStatementContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *ShowStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type ShowOpenTablesContext struct { + ShowStatementContext + schemaFormat antlr.Token +} + +func NewShowOpenTablesContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowOpenTablesContext { + var p = new(ShowOpenTablesContext) + + InitEmptyShowStatementContext(&p.ShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*ShowStatementContext)) + + return p +} + +func (s *ShowOpenTablesContext) GetSchemaFormat() antlr.Token { return s.schemaFormat } + +func (s *ShowOpenTablesContext) SetSchemaFormat(v antlr.Token) { s.schemaFormat = v } + +func (s *ShowOpenTablesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowOpenTablesContext) SHOW() antlr.TerminalNode { + return s.GetToken(MySqlParserSHOW, 0) +} + +func (s *ShowOpenTablesContext) OPEN() antlr.TerminalNode { + return s.GetToken(MySqlParserOPEN, 0) +} + +func (s *ShowOpenTablesContext) TABLES() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLES, 0) +} + +func (s *ShowOpenTablesContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *ShowOpenTablesContext) ShowFilter() IShowFilterContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShowFilterContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShowFilterContext) +} + +func (s *ShowOpenTablesContext) FROM() antlr.TerminalNode { + return s.GetToken(MySqlParserFROM, 0) +} + +func (s *ShowOpenTablesContext) IN() antlr.TerminalNode { + return s.GetToken(MySqlParserIN, 0) +} + +func (s *ShowOpenTablesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterShowOpenTables(s) + } +} + +func (s *ShowOpenTablesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitShowOpenTables(s) + } +} + +type ShowGlobalInfoContext struct { + ShowStatementContext +} + +func NewShowGlobalInfoContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowGlobalInfoContext { + var p = new(ShowGlobalInfoContext) + + InitEmptyShowStatementContext(&p.ShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*ShowStatementContext)) + + return p +} + +func (s *ShowGlobalInfoContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowGlobalInfoContext) SHOW() antlr.TerminalNode { + return s.GetToken(MySqlParserSHOW, 0) +} + +func (s *ShowGlobalInfoContext) ShowGlobalInfoClause() IShowGlobalInfoClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShowGlobalInfoClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShowGlobalInfoClauseContext) +} + +func (s *ShowGlobalInfoContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterShowGlobalInfo(s) + } +} + +func (s *ShowGlobalInfoContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitShowGlobalInfo(s) + } +} + +type ShowCreateFullIdObjectContext struct { + ShowStatementContext + namedEntity antlr.Token +} + +func NewShowCreateFullIdObjectContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowCreateFullIdObjectContext { + var p = new(ShowCreateFullIdObjectContext) + + InitEmptyShowStatementContext(&p.ShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*ShowStatementContext)) + + return p +} + +func (s *ShowCreateFullIdObjectContext) GetNamedEntity() antlr.Token { return s.namedEntity } + +func (s *ShowCreateFullIdObjectContext) SetNamedEntity(v antlr.Token) { s.namedEntity = v } + +func (s *ShowCreateFullIdObjectContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowCreateFullIdObjectContext) SHOW() antlr.TerminalNode { + return s.GetToken(MySqlParserSHOW, 0) +} + +func (s *ShowCreateFullIdObjectContext) CREATE() antlr.TerminalNode { + return s.GetToken(MySqlParserCREATE, 0) +} + +func (s *ShowCreateFullIdObjectContext) FullId() IFullIdContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFullIdContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFullIdContext) +} + +func (s *ShowCreateFullIdObjectContext) EVENT() antlr.TerminalNode { + return s.GetToken(MySqlParserEVENT, 0) +} + +func (s *ShowCreateFullIdObjectContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(MySqlParserFUNCTION, 0) +} + +func (s *ShowCreateFullIdObjectContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(MySqlParserPROCEDURE, 0) +} + +func (s *ShowCreateFullIdObjectContext) TABLE() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLE, 0) +} + +func (s *ShowCreateFullIdObjectContext) TRIGGER() antlr.TerminalNode { + return s.GetToken(MySqlParserTRIGGER, 0) +} + +func (s *ShowCreateFullIdObjectContext) VIEW() antlr.TerminalNode { + return s.GetToken(MySqlParserVIEW, 0) +} + +func (s *ShowCreateFullIdObjectContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterShowCreateFullIdObject(s) + } +} + +func (s *ShowCreateFullIdObjectContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitShowCreateFullIdObject(s) + } +} + +type ShowCreateUserContext struct { + ShowStatementContext +} + +func NewShowCreateUserContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowCreateUserContext { + var p = new(ShowCreateUserContext) + + InitEmptyShowStatementContext(&p.ShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*ShowStatementContext)) + + return p +} + +func (s *ShowCreateUserContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowCreateUserContext) SHOW() antlr.TerminalNode { + return s.GetToken(MySqlParserSHOW, 0) +} + +func (s *ShowCreateUserContext) CREATE() antlr.TerminalNode { + return s.GetToken(MySqlParserCREATE, 0) +} + +func (s *ShowCreateUserContext) USER() antlr.TerminalNode { + return s.GetToken(MySqlParserUSER, 0) +} + +func (s *ShowCreateUserContext) UserName() IUserNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUserNameContext) +} + +func (s *ShowCreateUserContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterShowCreateUser(s) + } +} + +func (s *ShowCreateUserContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitShowCreateUser(s) + } +} + +type ShowErrorsContext struct { + ShowStatementContext + errorFormat antlr.Token + offset IDecimalLiteralContext + rowCount IDecimalLiteralContext +} + +func NewShowErrorsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowErrorsContext { + var p = new(ShowErrorsContext) + + InitEmptyShowStatementContext(&p.ShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*ShowStatementContext)) + + return p +} + +func (s *ShowErrorsContext) GetErrorFormat() antlr.Token { return s.errorFormat } + +func (s *ShowErrorsContext) SetErrorFormat(v antlr.Token) { s.errorFormat = v } + +func (s *ShowErrorsContext) GetOffset() IDecimalLiteralContext { return s.offset } + +func (s *ShowErrorsContext) GetRowCount() IDecimalLiteralContext { return s.rowCount } + +func (s *ShowErrorsContext) SetOffset(v IDecimalLiteralContext) { s.offset = v } + +func (s *ShowErrorsContext) SetRowCount(v IDecimalLiteralContext) { s.rowCount = v } + +func (s *ShowErrorsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowErrorsContext) SHOW() antlr.TerminalNode { + return s.GetToken(MySqlParserSHOW, 0) +} + +func (s *ShowErrorsContext) ERRORS() antlr.TerminalNode { + return s.GetToken(MySqlParserERRORS, 0) +} + +func (s *ShowErrorsContext) WARNINGS() antlr.TerminalNode { + return s.GetToken(MySqlParserWARNINGS, 0) +} + +func (s *ShowErrorsContext) LIMIT() antlr.TerminalNode { + return s.GetToken(MySqlParserLIMIT, 0) +} + +func (s *ShowErrorsContext) AllDecimalLiteral() []IDecimalLiteralContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDecimalLiteralContext); ok { + len++ + } + } + + tst := make([]IDecimalLiteralContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDecimalLiteralContext); ok { + tst[i] = t.(IDecimalLiteralContext) + i++ + } + } + + return tst +} + +func (s *ShowErrorsContext) DecimalLiteral(i int) IDecimalLiteralContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *ShowErrorsContext) COMMA() antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, 0) +} + +func (s *ShowErrorsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterShowErrors(s) + } +} + +func (s *ShowErrorsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitShowErrors(s) + } +} + +type ShowCountErrorsContext struct { + ShowStatementContext + errorFormat antlr.Token +} + +func NewShowCountErrorsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowCountErrorsContext { + var p = new(ShowCountErrorsContext) + + InitEmptyShowStatementContext(&p.ShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*ShowStatementContext)) + + return p +} + +func (s *ShowCountErrorsContext) GetErrorFormat() antlr.Token { return s.errorFormat } + +func (s *ShowCountErrorsContext) SetErrorFormat(v antlr.Token) { s.errorFormat = v } + +func (s *ShowCountErrorsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowCountErrorsContext) SHOW() antlr.TerminalNode { + return s.GetToken(MySqlParserSHOW, 0) +} + +func (s *ShowCountErrorsContext) COUNT() antlr.TerminalNode { + return s.GetToken(MySqlParserCOUNT, 0) +} + +func (s *ShowCountErrorsContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *ShowCountErrorsContext) STAR() antlr.TerminalNode { + return s.GetToken(MySqlParserSTAR, 0) +} + +func (s *ShowCountErrorsContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *ShowCountErrorsContext) ERRORS() antlr.TerminalNode { + return s.GetToken(MySqlParserERRORS, 0) +} + +func (s *ShowCountErrorsContext) WARNINGS() antlr.TerminalNode { + return s.GetToken(MySqlParserWARNINGS, 0) +} + +func (s *ShowCountErrorsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterShowCountErrors(s) + } +} + +func (s *ShowCountErrorsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitShowCountErrors(s) + } +} + +type ShowObjectFilterContext struct { + ShowStatementContext +} + +func NewShowObjectFilterContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowObjectFilterContext { + var p = new(ShowObjectFilterContext) + + InitEmptyShowStatementContext(&p.ShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*ShowStatementContext)) + + return p +} + +func (s *ShowObjectFilterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowObjectFilterContext) SHOW() antlr.TerminalNode { + return s.GetToken(MySqlParserSHOW, 0) +} + +func (s *ShowObjectFilterContext) ShowCommonEntity() IShowCommonEntityContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShowCommonEntityContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShowCommonEntityContext) +} + +func (s *ShowObjectFilterContext) ShowFilter() IShowFilterContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShowFilterContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShowFilterContext) +} + +func (s *ShowObjectFilterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterShowObjectFilter(s) + } +} + +func (s *ShowObjectFilterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitShowObjectFilter(s) + } +} + +type ShowCreateDbContext struct { + ShowStatementContext + schemaFormat antlr.Token +} + +func NewShowCreateDbContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowCreateDbContext { + var p = new(ShowCreateDbContext) + + InitEmptyShowStatementContext(&p.ShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*ShowStatementContext)) + + return p +} + +func (s *ShowCreateDbContext) GetSchemaFormat() antlr.Token { return s.schemaFormat } + +func (s *ShowCreateDbContext) SetSchemaFormat(v antlr.Token) { s.schemaFormat = v } + +func (s *ShowCreateDbContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowCreateDbContext) SHOW() antlr.TerminalNode { + return s.GetToken(MySqlParserSHOW, 0) +} + +func (s *ShowCreateDbContext) CREATE() antlr.TerminalNode { + return s.GetToken(MySqlParserCREATE, 0) +} + +func (s *ShowCreateDbContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *ShowCreateDbContext) DATABASE() antlr.TerminalNode { + return s.GetToken(MySqlParserDATABASE, 0) +} + +func (s *ShowCreateDbContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(MySqlParserSCHEMA, 0) +} + +func (s *ShowCreateDbContext) IfNotExists() IIfNotExistsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfNotExistsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfNotExistsContext) +} + +func (s *ShowCreateDbContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterShowCreateDb(s) + } +} + +func (s *ShowCreateDbContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitShowCreateDb(s) + } +} + +type ShowEngineContext struct { + ShowStatementContext + engineOption antlr.Token +} + +func NewShowEngineContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowEngineContext { + var p = new(ShowEngineContext) + + InitEmptyShowStatementContext(&p.ShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*ShowStatementContext)) + + return p +} + +func (s *ShowEngineContext) GetEngineOption() antlr.Token { return s.engineOption } + +func (s *ShowEngineContext) SetEngineOption(v antlr.Token) { s.engineOption = v } + +func (s *ShowEngineContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowEngineContext) SHOW() antlr.TerminalNode { + return s.GetToken(MySqlParserSHOW, 0) +} + +func (s *ShowEngineContext) ENGINE() antlr.TerminalNode { + return s.GetToken(MySqlParserENGINE, 0) +} + +func (s *ShowEngineContext) EngineName() IEngineNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEngineNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEngineNameContext) +} + +func (s *ShowEngineContext) STATUS() antlr.TerminalNode { + return s.GetToken(MySqlParserSTATUS, 0) +} + +func (s *ShowEngineContext) MUTEX() antlr.TerminalNode { + return s.GetToken(MySqlParserMUTEX, 0) +} + +func (s *ShowEngineContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterShowEngine(s) + } +} + +func (s *ShowEngineContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitShowEngine(s) + } +} + +type ShowSchemaFilterContext struct { + ShowStatementContext + schemaFormat antlr.Token +} + +func NewShowSchemaFilterContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowSchemaFilterContext { + var p = new(ShowSchemaFilterContext) + + InitEmptyShowStatementContext(&p.ShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*ShowStatementContext)) + + return p +} + +func (s *ShowSchemaFilterContext) GetSchemaFormat() antlr.Token { return s.schemaFormat } + +func (s *ShowSchemaFilterContext) SetSchemaFormat(v antlr.Token) { s.schemaFormat = v } + +func (s *ShowSchemaFilterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowSchemaFilterContext) SHOW() antlr.TerminalNode { + return s.GetToken(MySqlParserSHOW, 0) +} + +func (s *ShowSchemaFilterContext) ShowSchemaEntity() IShowSchemaEntityContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShowSchemaEntityContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShowSchemaEntityContext) +} + +func (s *ShowSchemaFilterContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *ShowSchemaFilterContext) ShowFilter() IShowFilterContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShowFilterContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShowFilterContext) +} + +func (s *ShowSchemaFilterContext) FROM() antlr.TerminalNode { + return s.GetToken(MySqlParserFROM, 0) +} + +func (s *ShowSchemaFilterContext) IN() antlr.TerminalNode { + return s.GetToken(MySqlParserIN, 0) +} + +func (s *ShowSchemaFilterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterShowSchemaFilter(s) + } +} + +func (s *ShowSchemaFilterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitShowSchemaFilter(s) + } +} + +type ShowIndexesContext struct { + ShowStatementContext + indexFormat antlr.Token + tableFormat antlr.Token + schemaFormat antlr.Token +} + +func NewShowIndexesContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowIndexesContext { + var p = new(ShowIndexesContext) + + InitEmptyShowStatementContext(&p.ShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*ShowStatementContext)) + + return p +} + +func (s *ShowIndexesContext) GetIndexFormat() antlr.Token { return s.indexFormat } + +func (s *ShowIndexesContext) GetTableFormat() antlr.Token { return s.tableFormat } + +func (s *ShowIndexesContext) GetSchemaFormat() antlr.Token { return s.schemaFormat } + +func (s *ShowIndexesContext) SetIndexFormat(v antlr.Token) { s.indexFormat = v } + +func (s *ShowIndexesContext) SetTableFormat(v antlr.Token) { s.tableFormat = v } + +func (s *ShowIndexesContext) SetSchemaFormat(v antlr.Token) { s.schemaFormat = v } + +func (s *ShowIndexesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowIndexesContext) SHOW() antlr.TerminalNode { + return s.GetToken(MySqlParserSHOW, 0) +} + +func (s *ShowIndexesContext) TableName() ITableNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableNameContext) +} + +func (s *ShowIndexesContext) INDEX() antlr.TerminalNode { + return s.GetToken(MySqlParserINDEX, 0) +} + +func (s *ShowIndexesContext) INDEXES() antlr.TerminalNode { + return s.GetToken(MySqlParserINDEXES, 0) +} + +func (s *ShowIndexesContext) KEYS() antlr.TerminalNode { + return s.GetToken(MySqlParserKEYS, 0) +} + +func (s *ShowIndexesContext) AllFROM() []antlr.TerminalNode { + return s.GetTokens(MySqlParserFROM) +} + +func (s *ShowIndexesContext) FROM(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserFROM, i) +} + +func (s *ShowIndexesContext) AllIN() []antlr.TerminalNode { + return s.GetTokens(MySqlParserIN) +} + +func (s *ShowIndexesContext) IN(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserIN, i) +} + +func (s *ShowIndexesContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *ShowIndexesContext) WHERE() antlr.TerminalNode { + return s.GetToken(MySqlParserWHERE, 0) +} + +func (s *ShowIndexesContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *ShowIndexesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterShowIndexes(s) + } +} + +func (s *ShowIndexesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitShowIndexes(s) + } +} + +type ShowLogEventsContext struct { + ShowStatementContext + logFormat antlr.Token + filename antlr.Token + fromPosition IDecimalLiteralContext + offset IDecimalLiteralContext + rowCount IDecimalLiteralContext +} + +func NewShowLogEventsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowLogEventsContext { + var p = new(ShowLogEventsContext) + + InitEmptyShowStatementContext(&p.ShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*ShowStatementContext)) + + return p +} + +func (s *ShowLogEventsContext) GetLogFormat() antlr.Token { return s.logFormat } + +func (s *ShowLogEventsContext) GetFilename() antlr.Token { return s.filename } + +func (s *ShowLogEventsContext) SetLogFormat(v antlr.Token) { s.logFormat = v } + +func (s *ShowLogEventsContext) SetFilename(v antlr.Token) { s.filename = v } + +func (s *ShowLogEventsContext) GetFromPosition() IDecimalLiteralContext { return s.fromPosition } + +func (s *ShowLogEventsContext) GetOffset() IDecimalLiteralContext { return s.offset } + +func (s *ShowLogEventsContext) GetRowCount() IDecimalLiteralContext { return s.rowCount } + +func (s *ShowLogEventsContext) SetFromPosition(v IDecimalLiteralContext) { s.fromPosition = v } + +func (s *ShowLogEventsContext) SetOffset(v IDecimalLiteralContext) { s.offset = v } + +func (s *ShowLogEventsContext) SetRowCount(v IDecimalLiteralContext) { s.rowCount = v } + +func (s *ShowLogEventsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowLogEventsContext) SHOW() antlr.TerminalNode { + return s.GetToken(MySqlParserSHOW, 0) +} + +func (s *ShowLogEventsContext) EVENTS() antlr.TerminalNode { + return s.GetToken(MySqlParserEVENTS, 0) +} + +func (s *ShowLogEventsContext) BINLOG() antlr.TerminalNode { + return s.GetToken(MySqlParserBINLOG, 0) +} + +func (s *ShowLogEventsContext) RELAYLOG() antlr.TerminalNode { + return s.GetToken(MySqlParserRELAYLOG, 0) +} + +func (s *ShowLogEventsContext) IN() antlr.TerminalNode { + return s.GetToken(MySqlParserIN, 0) +} + +func (s *ShowLogEventsContext) FROM() antlr.TerminalNode { + return s.GetToken(MySqlParserFROM, 0) +} + +func (s *ShowLogEventsContext) LIMIT() antlr.TerminalNode { + return s.GetToken(MySqlParserLIMIT, 0) +} + +func (s *ShowLogEventsContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *ShowLogEventsContext) AllDecimalLiteral() []IDecimalLiteralContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDecimalLiteralContext); ok { + len++ + } + } + + tst := make([]IDecimalLiteralContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDecimalLiteralContext); ok { + tst[i] = t.(IDecimalLiteralContext) + i++ + } + } + + return tst +} + +func (s *ShowLogEventsContext) DecimalLiteral(i int) IDecimalLiteralContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *ShowLogEventsContext) COMMA() antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, 0) +} + +func (s *ShowLogEventsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterShowLogEvents(s) + } +} + +func (s *ShowLogEventsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitShowLogEvents(s) + } +} + +type ShowMasterLogsContext struct { + ShowStatementContext + logFormat antlr.Token +} + +func NewShowMasterLogsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowMasterLogsContext { + var p = new(ShowMasterLogsContext) + + InitEmptyShowStatementContext(&p.ShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*ShowStatementContext)) + + return p +} + +func (s *ShowMasterLogsContext) GetLogFormat() antlr.Token { return s.logFormat } + +func (s *ShowMasterLogsContext) SetLogFormat(v antlr.Token) { s.logFormat = v } + +func (s *ShowMasterLogsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowMasterLogsContext) SHOW() antlr.TerminalNode { + return s.GetToken(MySqlParserSHOW, 0) +} + +func (s *ShowMasterLogsContext) LOGS() antlr.TerminalNode { + return s.GetToken(MySqlParserLOGS, 0) +} + +func (s *ShowMasterLogsContext) BINARY() antlr.TerminalNode { + return s.GetToken(MySqlParserBINARY, 0) +} + +func (s *ShowMasterLogsContext) MASTER() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER, 0) +} + +func (s *ShowMasterLogsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterShowMasterLogs(s) + } +} + +func (s *ShowMasterLogsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitShowMasterLogs(s) + } +} + +type ShowGrantsContext struct { + ShowStatementContext +} + +func NewShowGrantsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowGrantsContext { + var p = new(ShowGrantsContext) + + InitEmptyShowStatementContext(&p.ShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*ShowStatementContext)) + + return p +} + +func (s *ShowGrantsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowGrantsContext) SHOW() antlr.TerminalNode { + return s.GetToken(MySqlParserSHOW, 0) +} + +func (s *ShowGrantsContext) GRANTS() antlr.TerminalNode { + return s.GetToken(MySqlParserGRANTS, 0) +} + +func (s *ShowGrantsContext) FOR() antlr.TerminalNode { + return s.GetToken(MySqlParserFOR, 0) +} + +func (s *ShowGrantsContext) UserName() IUserNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUserNameContext) +} + +func (s *ShowGrantsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterShowGrants(s) + } +} + +func (s *ShowGrantsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitShowGrants(s) + } +} + +type ShowSlaveStatusContext struct { + ShowStatementContext +} + +func NewShowSlaveStatusContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowSlaveStatusContext { + var p = new(ShowSlaveStatusContext) + + InitEmptyShowStatementContext(&p.ShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*ShowStatementContext)) + + return p +} + +func (s *ShowSlaveStatusContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowSlaveStatusContext) SHOW() antlr.TerminalNode { + return s.GetToken(MySqlParserSHOW, 0) +} + +func (s *ShowSlaveStatusContext) SLAVE() antlr.TerminalNode { + return s.GetToken(MySqlParserSLAVE, 0) +} + +func (s *ShowSlaveStatusContext) STATUS() antlr.TerminalNode { + return s.GetToken(MySqlParserSTATUS, 0) +} + +func (s *ShowSlaveStatusContext) FOR() antlr.TerminalNode { + return s.GetToken(MySqlParserFOR, 0) +} + +func (s *ShowSlaveStatusContext) CHANNEL() antlr.TerminalNode { + return s.GetToken(MySqlParserCHANNEL, 0) +} + +func (s *ShowSlaveStatusContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *ShowSlaveStatusContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterShowSlaveStatus(s) + } +} + +func (s *ShowSlaveStatusContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitShowSlaveStatus(s) + } +} + +type ShowRoutineContext struct { + ShowStatementContext + routine antlr.Token +} + +func NewShowRoutineContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowRoutineContext { + var p = new(ShowRoutineContext) + + InitEmptyShowStatementContext(&p.ShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*ShowStatementContext)) + + return p +} + +func (s *ShowRoutineContext) GetRoutine() antlr.Token { return s.routine } + +func (s *ShowRoutineContext) SetRoutine(v antlr.Token) { s.routine = v } + +func (s *ShowRoutineContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowRoutineContext) SHOW() antlr.TerminalNode { + return s.GetToken(MySqlParserSHOW, 0) +} + +func (s *ShowRoutineContext) CODE() antlr.TerminalNode { + return s.GetToken(MySqlParserCODE, 0) +} + +func (s *ShowRoutineContext) FullId() IFullIdContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFullIdContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFullIdContext) +} + +func (s *ShowRoutineContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(MySqlParserFUNCTION, 0) +} + +func (s *ShowRoutineContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(MySqlParserPROCEDURE, 0) +} + +func (s *ShowRoutineContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterShowRoutine(s) + } +} + +func (s *ShowRoutineContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitShowRoutine(s) + } +} + +type ShowProfileContext struct { + ShowStatementContext + queryCount IDecimalLiteralContext + offset IDecimalLiteralContext + rowCount IDecimalLiteralContext +} + +func NewShowProfileContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowProfileContext { + var p = new(ShowProfileContext) + + InitEmptyShowStatementContext(&p.ShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*ShowStatementContext)) + + return p +} + +func (s *ShowProfileContext) GetQueryCount() IDecimalLiteralContext { return s.queryCount } + +func (s *ShowProfileContext) GetOffset() IDecimalLiteralContext { return s.offset } + +func (s *ShowProfileContext) GetRowCount() IDecimalLiteralContext { return s.rowCount } + +func (s *ShowProfileContext) SetQueryCount(v IDecimalLiteralContext) { s.queryCount = v } + +func (s *ShowProfileContext) SetOffset(v IDecimalLiteralContext) { s.offset = v } + +func (s *ShowProfileContext) SetRowCount(v IDecimalLiteralContext) { s.rowCount = v } + +func (s *ShowProfileContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowProfileContext) SHOW() antlr.TerminalNode { + return s.GetToken(MySqlParserSHOW, 0) +} + +func (s *ShowProfileContext) PROFILE() antlr.TerminalNode { + return s.GetToken(MySqlParserPROFILE, 0) +} + +func (s *ShowProfileContext) AllShowProfileType() []IShowProfileTypeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IShowProfileTypeContext); ok { + len++ + } + } + + tst := make([]IShowProfileTypeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IShowProfileTypeContext); ok { + tst[i] = t.(IShowProfileTypeContext) + i++ + } + } + + return tst +} + +func (s *ShowProfileContext) ShowProfileType(i int) IShowProfileTypeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShowProfileTypeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IShowProfileTypeContext) +} + +func (s *ShowProfileContext) LIMIT() antlr.TerminalNode { + return s.GetToken(MySqlParserLIMIT, 0) +} + +func (s *ShowProfileContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *ShowProfileContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *ShowProfileContext) FOR() antlr.TerminalNode { + return s.GetToken(MySqlParserFOR, 0) +} + +func (s *ShowProfileContext) QUERY() antlr.TerminalNode { + return s.GetToken(MySqlParserQUERY, 0) +} + +func (s *ShowProfileContext) AllDecimalLiteral() []IDecimalLiteralContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDecimalLiteralContext); ok { + len++ + } + } + + tst := make([]IDecimalLiteralContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDecimalLiteralContext); ok { + tst[i] = t.(IDecimalLiteralContext) + i++ + } + } + + return tst +} + +func (s *ShowProfileContext) DecimalLiteral(i int) IDecimalLiteralContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *ShowProfileContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterShowProfile(s) + } +} + +func (s *ShowProfileContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitShowProfile(s) + } +} + +type ShowColumnsContext struct { + ShowStatementContext + columnsFormat antlr.Token + tableFormat antlr.Token + schemaFormat antlr.Token +} + +func NewShowColumnsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowColumnsContext { + var p = new(ShowColumnsContext) + + InitEmptyShowStatementContext(&p.ShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*ShowStatementContext)) + + return p +} + +func (s *ShowColumnsContext) GetColumnsFormat() antlr.Token { return s.columnsFormat } + +func (s *ShowColumnsContext) GetTableFormat() antlr.Token { return s.tableFormat } + +func (s *ShowColumnsContext) GetSchemaFormat() antlr.Token { return s.schemaFormat } + +func (s *ShowColumnsContext) SetColumnsFormat(v antlr.Token) { s.columnsFormat = v } + +func (s *ShowColumnsContext) SetTableFormat(v antlr.Token) { s.tableFormat = v } + +func (s *ShowColumnsContext) SetSchemaFormat(v antlr.Token) { s.schemaFormat = v } + +func (s *ShowColumnsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowColumnsContext) SHOW() antlr.TerminalNode { + return s.GetToken(MySqlParserSHOW, 0) +} + +func (s *ShowColumnsContext) TableName() ITableNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableNameContext) +} + +func (s *ShowColumnsContext) COLUMNS() antlr.TerminalNode { + return s.GetToken(MySqlParserCOLUMNS, 0) +} + +func (s *ShowColumnsContext) FIELDS() antlr.TerminalNode { + return s.GetToken(MySqlParserFIELDS, 0) +} + +func (s *ShowColumnsContext) AllFROM() []antlr.TerminalNode { + return s.GetTokens(MySqlParserFROM) +} + +func (s *ShowColumnsContext) FROM(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserFROM, i) +} + +func (s *ShowColumnsContext) AllIN() []antlr.TerminalNode { + return s.GetTokens(MySqlParserIN) +} + +func (s *ShowColumnsContext) IN(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserIN, i) +} + +func (s *ShowColumnsContext) FULL() antlr.TerminalNode { + return s.GetToken(MySqlParserFULL, 0) +} + +func (s *ShowColumnsContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *ShowColumnsContext) ShowFilter() IShowFilterContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShowFilterContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShowFilterContext) +} + +func (s *ShowColumnsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterShowColumns(s) + } +} + +func (s *ShowColumnsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitShowColumns(s) + } +} + +func (p *MySqlParser) ShowStatement() (localctx IShowStatementContext) { + localctx = NewShowStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 490, MySqlParserRULE_showStatement) + var _la int + + p.SetState(5940) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 867, p.GetParserRuleContext()) { + case 1: + localctx = NewShowMasterLogsContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5787) + p.Match(MySqlParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5788) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*ShowMasterLogsContext).logFormat = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserBINARY || _la == MySqlParserMASTER) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*ShowMasterLogsContext).logFormat = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(5789) + p.Match(MySqlParserLOGS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + localctx = NewShowLogEventsContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5790) + p.Match(MySqlParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5791) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*ShowLogEventsContext).logFormat = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserBINLOG || _la == MySqlParserRELAYLOG) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*ShowLogEventsContext).logFormat = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(5792) + p.Match(MySqlParserEVENTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5795) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserIN { + { + p.SetState(5793) + p.Match(MySqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5794) + + var _m = p.Match(MySqlParserSTRING_LITERAL) + + localctx.(*ShowLogEventsContext).filename = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(5799) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserFROM { + { + p.SetState(5797) + p.Match(MySqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5798) + + var _x = p.DecimalLiteral() + + localctx.(*ShowLogEventsContext).fromPosition = _x + } + + } + p.SetState(5808) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserLIMIT { + { + p.SetState(5801) + p.Match(MySqlParserLIMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5805) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 847, p.GetParserRuleContext()) == 1 { + { + p.SetState(5802) + + var _x = p.DecimalLiteral() + + localctx.(*ShowLogEventsContext).offset = _x + } + { + p.SetState(5803) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5807) + + var _x = p.DecimalLiteral() + + localctx.(*ShowLogEventsContext).rowCount = _x + } + + } + + case 3: + localctx = NewShowObjectFilterContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5810) + p.Match(MySqlParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5811) + p.ShowCommonEntity() + } + p.SetState(5813) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserLIKE || _la == MySqlParserWHERE { + { + p.SetState(5812) + p.ShowFilter() + } + + } + + case 4: + localctx = NewShowColumnsContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5815) + p.Match(MySqlParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5817) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserFULL { + { + p.SetState(5816) + p.Match(MySqlParserFULL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5819) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*ShowColumnsContext).columnsFormat = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserCOLUMNS || _la == MySqlParserFIELDS) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*ShowColumnsContext).columnsFormat = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(5820) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*ShowColumnsContext).tableFormat = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserFROM || _la == MySqlParserIN) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*ShowColumnsContext).tableFormat = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(5821) + p.TableName() + } + p.SetState(5824) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserFROM || _la == MySqlParserIN { + { + p.SetState(5822) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*ShowColumnsContext).schemaFormat = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserFROM || _la == MySqlParserIN) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*ShowColumnsContext).schemaFormat = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(5823) + p.Uid() + } + + } + p.SetState(5827) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserLIKE || _la == MySqlParserWHERE { + { + p.SetState(5826) + p.ShowFilter() + } + + } + + case 5: + localctx = NewShowCreateDbContext(p, localctx) + p.EnterOuterAlt(localctx, 5) + { + p.SetState(5829) + p.Match(MySqlParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5830) + p.Match(MySqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5831) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*ShowCreateDbContext).schemaFormat = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserDATABASE || _la == MySqlParserSCHEMA) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*ShowCreateDbContext).schemaFormat = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(5833) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 853, p.GetParserRuleContext()) == 1 { + { + p.SetState(5832) + p.IfNotExists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5835) + p.Uid() + } + + case 6: + localctx = NewShowCreateFullIdObjectContext(p, localctx) + p.EnterOuterAlt(localctx, 6) + { + p.SetState(5836) + p.Match(MySqlParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5837) + p.Match(MySqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5838) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*ShowCreateFullIdObjectContext).namedEntity = _lt + + _la = p.GetTokenStream().LA(1) + + if !(((int64((_la-131)) & ^0x3f) == 0 && ((int64(1)<<(_la-131))&72567767433217) != 0) || _la == MySqlParserEVENT || _la == MySqlParserFUNCTION || _la == MySqlParserVIEW) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*ShowCreateFullIdObjectContext).namedEntity = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(5839) + p.FullId() + } + + case 7: + localctx = NewShowCreateUserContext(p, localctx) + p.EnterOuterAlt(localctx, 7) + { + p.SetState(5840) + p.Match(MySqlParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5841) + p.Match(MySqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5842) + p.Match(MySqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5843) + p.UserName() + } + + case 8: + localctx = NewShowEngineContext(p, localctx) + p.EnterOuterAlt(localctx, 8) + { + p.SetState(5844) + p.Match(MySqlParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5845) + p.Match(MySqlParserENGINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5846) + p.EngineName() + } + { + p.SetState(5847) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*ShowEngineContext).engineOption = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserMUTEX || _la == MySqlParserSTATUS) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*ShowEngineContext).engineOption = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 9: + localctx = NewShowGlobalInfoContext(p, localctx) + p.EnterOuterAlt(localctx, 9) + { + p.SetState(5849) + p.Match(MySqlParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5850) + p.ShowGlobalInfoClause() + } + + case 10: + localctx = NewShowErrorsContext(p, localctx) + p.EnterOuterAlt(localctx, 10) + { + p.SetState(5851) + p.Match(MySqlParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5852) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*ShowErrorsContext).errorFormat = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserERRORS || _la == MySqlParserWARNINGS) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*ShowErrorsContext).errorFormat = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(5860) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserLIMIT { + { + p.SetState(5853) + p.Match(MySqlParserLIMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5857) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 854, p.GetParserRuleContext()) == 1 { + { + p.SetState(5854) + + var _x = p.DecimalLiteral() + + localctx.(*ShowErrorsContext).offset = _x + } + { + p.SetState(5855) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5859) + + var _x = p.DecimalLiteral() + + localctx.(*ShowErrorsContext).rowCount = _x + } + + } + + case 11: + localctx = NewShowCountErrorsContext(p, localctx) + p.EnterOuterAlt(localctx, 11) + { + p.SetState(5862) + p.Match(MySqlParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5863) + p.Match(MySqlParserCOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5864) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5865) + p.Match(MySqlParserSTAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5866) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5867) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*ShowCountErrorsContext).errorFormat = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserERRORS || _la == MySqlParserWARNINGS) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*ShowCountErrorsContext).errorFormat = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 12: + localctx = NewShowSchemaFilterContext(p, localctx) + p.EnterOuterAlt(localctx, 12) + { + p.SetState(5868) + p.Match(MySqlParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5869) + p.ShowSchemaEntity() + } + p.SetState(5872) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserFROM || _la == MySqlParserIN { + { + p.SetState(5870) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*ShowSchemaFilterContext).schemaFormat = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserFROM || _la == MySqlParserIN) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*ShowSchemaFilterContext).schemaFormat = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(5871) + p.Uid() + } + + } + p.SetState(5875) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserLIKE || _la == MySqlParserWHERE { + { + p.SetState(5874) + p.ShowFilter() + } + + } + + case 13: + localctx = NewShowRoutineContext(p, localctx) + p.EnterOuterAlt(localctx, 13) + { + p.SetState(5877) + p.Match(MySqlParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5878) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*ShowRoutineContext).routine = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserPROCEDURE || _la == MySqlParserFUNCTION) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*ShowRoutineContext).routine = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(5879) + p.Match(MySqlParserCODE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5880) + p.FullId() + } + + case 14: + localctx = NewShowGrantsContext(p, localctx) + p.EnterOuterAlt(localctx, 14) + { + p.SetState(5881) + p.Match(MySqlParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5882) + p.Match(MySqlParserGRANTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5885) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserFOR { + { + p.SetState(5883) + p.Match(MySqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5884) + p.UserName() + } + + } + + case 15: + localctx = NewShowIndexesContext(p, localctx) + p.EnterOuterAlt(localctx, 15) + { + p.SetState(5887) + p.Match(MySqlParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5888) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*ShowIndexesContext).indexFormat = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserINDEX || _la == MySqlParserKEYS || _la == MySqlParserINDEXES) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*ShowIndexesContext).indexFormat = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(5889) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*ShowIndexesContext).tableFormat = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserFROM || _la == MySqlParserIN) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*ShowIndexesContext).tableFormat = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(5890) + p.TableName() + } + p.SetState(5893) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserFROM || _la == MySqlParserIN { + { + p.SetState(5891) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*ShowIndexesContext).schemaFormat = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserFROM || _la == MySqlParserIN) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*ShowIndexesContext).schemaFormat = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(5892) + p.Uid() + } + + } + p.SetState(5897) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserWHERE { + { + p.SetState(5895) + p.Match(MySqlParserWHERE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5896) + p.expression(0) + } + + } + + case 16: + localctx = NewShowOpenTablesContext(p, localctx) + p.EnterOuterAlt(localctx, 16) + { + p.SetState(5899) + p.Match(MySqlParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5900) + p.Match(MySqlParserOPEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5901) + p.Match(MySqlParserTABLES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5904) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserFROM || _la == MySqlParserIN { + { + p.SetState(5902) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*ShowOpenTablesContext).schemaFormat = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserFROM || _la == MySqlParserIN) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*ShowOpenTablesContext).schemaFormat = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(5903) + p.Uid() + } + + } + p.SetState(5907) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserLIKE || _la == MySqlParserWHERE { + { + p.SetState(5906) + p.ShowFilter() + } + + } + + case 17: + localctx = NewShowProfileContext(p, localctx) + p.EnterOuterAlt(localctx, 17) + { + p.SetState(5909) + p.Match(MySqlParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5910) + p.Match(MySqlParserPROFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5911) + p.ShowProfileType() + } + p.SetState(5916) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(5912) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5913) + p.ShowProfileType() + } + + p.SetState(5918) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(5922) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserFOR { + { + p.SetState(5919) + p.Match(MySqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5920) + p.Match(MySqlParserQUERY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5921) + + var _x = p.DecimalLiteral() + + localctx.(*ShowProfileContext).queryCount = _x + } + + } + + { + p.SetState(5924) + p.Match(MySqlParserLIMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5928) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 865, p.GetParserRuleContext()) == 1 { + { + p.SetState(5925) + + var _x = p.DecimalLiteral() + + localctx.(*ShowProfileContext).offset = _x + } + { + p.SetState(5926) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5930) + + var _x = p.DecimalLiteral() + + localctx.(*ShowProfileContext).rowCount = _x + } + + case 18: + localctx = NewShowSlaveStatusContext(p, localctx) + p.EnterOuterAlt(localctx, 18) + { + p.SetState(5932) + p.Match(MySqlParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5933) + p.Match(MySqlParserSLAVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5934) + p.Match(MySqlParserSTATUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5938) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserFOR { + { + p.SetState(5935) + p.Match(MySqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5936) + p.Match(MySqlParserCHANNEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5937) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IVariableClauseContext is an interface to support dynamic dispatch. +type IVariableClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LOCAL_ID() antlr.TerminalNode + GLOBAL_ID() antlr.TerminalNode + Uid() IUidContext + GLOBAL() antlr.TerminalNode + SESSION() antlr.TerminalNode + LOCAL() antlr.TerminalNode + AllAT_SIGN() []antlr.TerminalNode + AT_SIGN(i int) antlr.TerminalNode + + // IsVariableClauseContext differentiates from other interfaces. + IsVariableClauseContext() +} + +type VariableClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyVariableClauseContext() *VariableClauseContext { + var p = new(VariableClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_variableClause + return p +} + +func InitEmptyVariableClauseContext(p *VariableClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_variableClause +} + +func (*VariableClauseContext) IsVariableClauseContext() {} + +func NewVariableClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariableClauseContext { + var p = new(VariableClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_variableClause + + return p +} + +func (s *VariableClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *VariableClauseContext) LOCAL_ID() antlr.TerminalNode { + return s.GetToken(MySqlParserLOCAL_ID, 0) +} + +func (s *VariableClauseContext) GLOBAL_ID() antlr.TerminalNode { + return s.GetToken(MySqlParserGLOBAL_ID, 0) +} + +func (s *VariableClauseContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *VariableClauseContext) GLOBAL() antlr.TerminalNode { + return s.GetToken(MySqlParserGLOBAL, 0) +} + +func (s *VariableClauseContext) SESSION() antlr.TerminalNode { + return s.GetToken(MySqlParserSESSION, 0) +} + +func (s *VariableClauseContext) LOCAL() antlr.TerminalNode { + return s.GetToken(MySqlParserLOCAL, 0) +} + +func (s *VariableClauseContext) AllAT_SIGN() []antlr.TerminalNode { + return s.GetTokens(MySqlParserAT_SIGN) +} + +func (s *VariableClauseContext) AT_SIGN(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserAT_SIGN, i) +} + +func (s *VariableClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *VariableClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *VariableClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterVariableClause(s) + } +} + +func (s *VariableClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitVariableClause(s) + } +} + +func (p *MySqlParser) VariableClause() (localctx IVariableClauseContext) { + localctx = NewVariableClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 492, MySqlParserRULE_variableClause) + var _la int + + p.SetState(5952) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserLOCAL_ID: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5942) + p.Match(MySqlParserLOCAL_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserGLOBAL_ID: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5943) + p.Match(MySqlParserGLOBAL_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserARRAY, MySqlParserATTRIBUTE, MySqlParserBUCKETS, MySqlParserCONDITION, MySqlParserCURRENT, MySqlParserCURRENT_USER, MySqlParserDATABASE, MySqlParserDEFAULT, MySqlParserDIAGNOSTICS, MySqlParserEMPTY, MySqlParserENFORCED, MySqlParserEXCEPT, MySqlParserGROUP, MySqlParserIF, MySqlParserIGNORED, MySqlParserINSERT, MySqlParserLATERAL, MySqlParserLEFT, MySqlParserNUMBER, MySqlParserOPTIONAL, MySqlParserORDER, MySqlParserPRIMARY, MySqlParserREPEAT, MySqlParserREPLACE, MySqlParserRIGHT, MySqlParserSCHEMA, MySqlParserSKIP_QUERY_REWRITE, MySqlParserSTACKED, MySqlParserSTATEMENT, MySqlParserDATE, MySqlParserTIME, MySqlParserTIMESTAMP, MySqlParserDATETIME, MySqlParserYEAR, MySqlParserBINARY, MySqlParserTEXT, MySqlParserENUM, MySqlParserSERIAL, MySqlParserJSON_ARRAY, MySqlParserJSON_ARRAYAGG, MySqlParserJSON_ARRAY_APPEND, MySqlParserJSON_ARRAY_INSERT, MySqlParserJSON_CONTAINS, MySqlParserJSON_CONTAINS_PATH, MySqlParserJSON_DEPTH, MySqlParserJSON_EXTRACT, MySqlParserJSON_INSERT, MySqlParserJSON_KEYS, MySqlParserJSON_LENGTH, MySqlParserJSON_MERGE, MySqlParserJSON_MERGE_PATCH, MySqlParserJSON_MERGE_PRESERVE, MySqlParserJSON_OBJECT, MySqlParserJSON_OBJECTAGG, MySqlParserJSON_OVERLAPS, MySqlParserJSON_PRETTY, MySqlParserJSON_QUOTE, MySqlParserJSON_REMOVE, MySqlParserJSON_REPLACE, MySqlParserJSON_SCHEMA_VALID, MySqlParserJSON_SCHEMA_VALIDATION_REPORT, MySqlParserJSON_SEARCH, MySqlParserJSON_SET, MySqlParserJSON_STORAGE_FREE, MySqlParserJSON_STORAGE_SIZE, MySqlParserJSON_TABLE, MySqlParserJSON_TYPE, MySqlParserJSON_UNQUOTE, MySqlParserJSON_VALID, MySqlParserJSON_VALUE, MySqlParserNESTED, MySqlParserORDINALITY, MySqlParserPATH, MySqlParserAVG, MySqlParserBIT_AND, MySqlParserBIT_OR, MySqlParserBIT_XOR, MySqlParserCOUNT, MySqlParserCUME_DIST, MySqlParserDENSE_RANK, MySqlParserFIRST_VALUE, MySqlParserGROUP_CONCAT, MySqlParserLAG, MySqlParserLAST_VALUE, MySqlParserLEAD, MySqlParserMAX, MySqlParserMIN, MySqlParserNTILE, MySqlParserNTH_VALUE, MySqlParserPERCENT_RANK, MySqlParserRANK, MySqlParserROW_NUMBER, MySqlParserSTD, MySqlParserSTDDEV, MySqlParserSTDDEV_POP, MySqlParserSTDDEV_SAMP, MySqlParserSUM, MySqlParserVAR_POP, MySqlParserVAR_SAMP, MySqlParserVARIANCE, MySqlParserCURRENT_DATE, MySqlParserCURRENT_TIME, MySqlParserCURRENT_TIMESTAMP, MySqlParserLOCALTIME, MySqlParserCURDATE, MySqlParserCURTIME, MySqlParserDATE_ADD, MySqlParserDATE_SUB, MySqlParserLOCALTIMESTAMP, MySqlParserNOW, MySqlParserPOSITION, MySqlParserSUBSTR, MySqlParserSUBSTRING, MySqlParserSYSDATE, MySqlParserTRIM, MySqlParserUTC_DATE, MySqlParserUTC_TIME, MySqlParserUTC_TIMESTAMP, MySqlParserACCOUNT, MySqlParserACTION, MySqlParserAFTER, MySqlParserAGGREGATE, MySqlParserALGORITHM, MySqlParserANY, MySqlParserAT, MySqlParserAUTHORS, MySqlParserAUTOCOMMIT, MySqlParserAUTOEXTEND_SIZE, MySqlParserAUTO_INCREMENT, MySqlParserAVG_ROW_LENGTH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserBIT, MySqlParserBLOCK, MySqlParserBOOL, MySqlParserBOOLEAN, MySqlParserBTREE, MySqlParserCACHE, MySqlParserCASCADED, MySqlParserCHAIN, MySqlParserCHANGED, MySqlParserCHANNEL, MySqlParserCHECKSUM, MySqlParserPAGE_CHECKSUM, MySqlParserCIPHER, MySqlParserCLASS_ORIGIN, MySqlParserCLIENT, MySqlParserCLOSE, MySqlParserCLUSTERING, MySqlParserCOALESCE, MySqlParserCODE, MySqlParserCOLUMNS, MySqlParserCOLUMN_FORMAT, MySqlParserCOLUMN_NAME, MySqlParserCOMMENT, MySqlParserCOMMIT, MySqlParserCOMPACT, MySqlParserCOMPLETION, MySqlParserCOMPRESSED, MySqlParserCOMPRESSION, MySqlParserCONCURRENT, MySqlParserCONNECT, MySqlParserCONNECTION, MySqlParserCONSISTENT, MySqlParserCONSTRAINT_CATALOG, MySqlParserCONSTRAINT_SCHEMA, MySqlParserCONSTRAINT_NAME, MySqlParserCONTAINS, MySqlParserCONTEXT, MySqlParserCONTRIBUTORS, MySqlParserCOPY, MySqlParserCPU, MySqlParserCURSOR_NAME, MySqlParserDATA, MySqlParserDATAFILE, MySqlParserDEALLOCATE, MySqlParserDEFAULT_AUTH, MySqlParserDEFINER, MySqlParserDELAY_KEY_WRITE, MySqlParserDES_KEY_FILE, MySqlParserDIRECTORY, MySqlParserDISABLE, MySqlParserDISCARD, MySqlParserDISK, MySqlParserDO, MySqlParserDUMPFILE, MySqlParserDUPLICATE, MySqlParserDYNAMIC, MySqlParserENABLE, MySqlParserENCRYPTION, MySqlParserEND, MySqlParserENDS, MySqlParserENGINE, MySqlParserENGINES, MySqlParserERROR, MySqlParserERRORS, MySqlParserESCAPE, MySqlParserEVEN, MySqlParserEVENT, MySqlParserEVENTS, MySqlParserEVERY, MySqlParserEXCHANGE, MySqlParserEXCLUSIVE, MySqlParserEXPIRE, MySqlParserEXPORT, MySqlParserEXTENDED, MySqlParserEXTENT_SIZE, MySqlParserFAILED_LOGIN_ATTEMPTS, MySqlParserFAST, MySqlParserFAULTS, MySqlParserFIELDS, MySqlParserFILE_BLOCK_SIZE, MySqlParserFILTER, MySqlParserFIRST, MySqlParserFIXED, MySqlParserFLUSH, MySqlParserFOLLOWS, MySqlParserFOUND, MySqlParserFULL, MySqlParserFUNCTION, MySqlParserGENERAL, MySqlParserGLOBAL, MySqlParserGRANTS, MySqlParserGROUP_REPLICATION, MySqlParserHANDLER, MySqlParserHASH, MySqlParserHELP, MySqlParserHISTORY, MySqlParserHOST, MySqlParserHOSTS, MySqlParserIDENTIFIED, MySqlParserIGNORE_SERVER_IDS, MySqlParserIMPORT, MySqlParserINDEXES, MySqlParserINITIAL_SIZE, MySqlParserINPLACE, MySqlParserINSERT_METHOD, MySqlParserINSTALL, MySqlParserINSTANCE, MySqlParserINSTANT, MySqlParserINVISIBLE, MySqlParserINVOKER, MySqlParserIO, MySqlParserIO_THREAD, MySqlParserIPC, MySqlParserISOLATION, MySqlParserISSUER, MySqlParserJSON, MySqlParserKEY_BLOCK_SIZE, MySqlParserLANGUAGE, MySqlParserLAST, MySqlParserLEAVES, MySqlParserLESS, MySqlParserLEVEL, MySqlParserLIST, MySqlParserLOCAL, MySqlParserLOGFILE, MySqlParserLOGS, MySqlParserMASTER, MySqlParserMASTER_AUTO_POSITION, MySqlParserMASTER_CONNECT_RETRY, MySqlParserMASTER_DELAY, MySqlParserMASTER_HEARTBEAT_PERIOD, MySqlParserMASTER_HOST, MySqlParserMASTER_LOG_FILE, MySqlParserMASTER_LOG_POS, MySqlParserMASTER_PASSWORD, MySqlParserMASTER_PORT, MySqlParserMASTER_RETRY_COUNT, MySqlParserMASTER_SSL, MySqlParserMASTER_SSL_CA, MySqlParserMASTER_SSL_CAPATH, MySqlParserMASTER_SSL_CERT, MySqlParserMASTER_SSL_CIPHER, MySqlParserMASTER_SSL_CRL, MySqlParserMASTER_SSL_CRLPATH, MySqlParserMASTER_SSL_KEY, MySqlParserMASTER_TLS_VERSION, MySqlParserMASTER_USER, MySqlParserMAX_CONNECTIONS_PER_HOUR, MySqlParserMAX_QUERIES_PER_HOUR, MySqlParserMAX_ROWS, MySqlParserMAX_SIZE, MySqlParserMAX_UPDATES_PER_HOUR, MySqlParserMAX_USER_CONNECTIONS, MySqlParserMEDIUM, MySqlParserMEMBER, MySqlParserMERGE, MySqlParserMESSAGE_TEXT, MySqlParserMID, MySqlParserMIGRATE, MySqlParserMIN_ROWS, MySqlParserMODE, MySqlParserMODIFY, MySqlParserMUTEX, MySqlParserMYSQL, MySqlParserMYSQL_ERRNO, MySqlParserNAME, MySqlParserNAMES, MySqlParserNCHAR, MySqlParserNEVER, MySqlParserNEXT, MySqlParserNO, MySqlParserNOCOPY, MySqlParserNOWAIT, MySqlParserNODEGROUP, MySqlParserNONE, MySqlParserODBC, MySqlParserOFFLINE, MySqlParserOFFSET, MySqlParserOF, MySqlParserOJ, MySqlParserOLD_PASSWORD, MySqlParserONE, MySqlParserONLINE, MySqlParserONLY, MySqlParserOPEN, MySqlParserOPTIMIZER_COSTS, MySqlParserOPTIONS, MySqlParserOWNER, MySqlParserPACK_KEYS, MySqlParserPAGE, MySqlParserPARSER, MySqlParserPARTIAL, MySqlParserPARTITIONING, MySqlParserPARTITIONS, MySqlParserPASSWORD, MySqlParserPASSWORD_LOCK_TIME, MySqlParserPHASE, MySqlParserPLUGIN, MySqlParserPLUGIN_DIR, MySqlParserPLUGINS, MySqlParserPORT, MySqlParserPRECEDES, MySqlParserPREPARE, MySqlParserPRESERVE, MySqlParserPREV, MySqlParserPROCESSLIST, MySqlParserPROFILE, MySqlParserPROFILES, MySqlParserPROXY, MySqlParserQUERY, MySqlParserQUICK, MySqlParserREBUILD, MySqlParserRECOVER, MySqlParserRECURSIVE, MySqlParserREDO_BUFFER_SIZE, MySqlParserREDUNDANT, MySqlParserRELAY, MySqlParserRELAY_LOG_FILE, MySqlParserRELAY_LOG_POS, MySqlParserRELAYLOG, MySqlParserREMOVE, MySqlParserREORGANIZE, MySqlParserREPAIR, MySqlParserREPLICATE_DO_DB, MySqlParserREPLICATE_DO_TABLE, MySqlParserREPLICATE_IGNORE_DB, MySqlParserREPLICATE_IGNORE_TABLE, MySqlParserREPLICATE_REWRITE_DB, MySqlParserREPLICATE_WILD_DO_TABLE, MySqlParserREPLICATE_WILD_IGNORE_TABLE, MySqlParserREPLICATION, MySqlParserRESET, MySqlParserRESUME, MySqlParserRETURNED_SQLSTATE, MySqlParserRETURNING, MySqlParserRETURNS, MySqlParserREUSE, MySqlParserROLE, MySqlParserROLLBACK, MySqlParserROLLUP, MySqlParserROTATE, MySqlParserROW, MySqlParserROWS, MySqlParserROW_FORMAT, MySqlParserRTREE, MySqlParserSAVEPOINT, MySqlParserSCHEDULE, MySqlParserSECURITY, MySqlParserSERVER, MySqlParserSESSION, MySqlParserSHARE, MySqlParserSHARED, MySqlParserSIGNED, MySqlParserSIMPLE, MySqlParserSLAVE, MySqlParserSLOW, MySqlParserSNAPSHOT, MySqlParserSOCKET, MySqlParserSOME, MySqlParserSONAME, MySqlParserSOUNDS, MySqlParserSOURCE, MySqlParserSQL_AFTER_GTIDS, MySqlParserSQL_AFTER_MTS_GAPS, MySqlParserSQL_BEFORE_GTIDS, MySqlParserSQL_BUFFER_RESULT, MySqlParserSQL_CACHE, MySqlParserSQL_NO_CACHE, MySqlParserSQL_THREAD, MySqlParserSTART, MySqlParserSTARTS, MySqlParserSTATS_AUTO_RECALC, MySqlParserSTATS_PERSISTENT, MySqlParserSTATS_SAMPLE_PAGES, MySqlParserSTATUS, MySqlParserSTOP, MySqlParserSTORAGE, MySqlParserSTRING, MySqlParserSUBCLASS_ORIGIN, MySqlParserSUBJECT, MySqlParserSUBPARTITION, MySqlParserSUBPARTITIONS, MySqlParserSUSPEND, MySqlParserSWAPS, MySqlParserSWITCHES, MySqlParserTABLE_NAME, MySqlParserTABLESPACE, MySqlParserTABLE_TYPE, MySqlParserTEMPORARY, MySqlParserTEMPTABLE, MySqlParserTHAN, MySqlParserTRADITIONAL, MySqlParserTRANSACTION, MySqlParserTRANSACTIONAL, MySqlParserTRIGGERS, MySqlParserTRUNCATE, MySqlParserUNBOUNDED, MySqlParserUNDEFINED, MySqlParserUNDOFILE, MySqlParserUNDO_BUFFER_SIZE, MySqlParserUNINSTALL, MySqlParserUNKNOWN, MySqlParserUNTIL, MySqlParserUPGRADE, MySqlParserUSER, MySqlParserUSE_FRM, MySqlParserUSER_RESOURCES, MySqlParserVALIDATION, MySqlParserVALUE, MySqlParserVARIABLES, MySqlParserVIEW, MySqlParserVIRTUAL, MySqlParserVISIBLE, MySqlParserWAIT, MySqlParserWARNINGS, MySqlParserWITHOUT, MySqlParserWORK, MySqlParserWRAPPER, MySqlParserX509, MySqlParserXA, MySqlParserXML, MySqlParserYES, MySqlParserEUR, MySqlParserUSA, MySqlParserJIS, MySqlParserISO, MySqlParserINTERNAL, MySqlParserQUARTER, MySqlParserMONTH, MySqlParserDAY, MySqlParserHOUR, MySqlParserMINUTE, MySqlParserWEEK, MySqlParserSECOND, MySqlParserMICROSECOND, MySqlParserADMIN, MySqlParserAUDIT_ABORT_EXEMPT, MySqlParserAUDIT_ADMIN, MySqlParserAUTHENTICATION_POLICY_ADMIN, MySqlParserBACKUP_ADMIN, MySqlParserBINLOG_ADMIN, MySqlParserBINLOG_ENCRYPTION_ADMIN, MySqlParserCLONE_ADMIN, MySqlParserCONNECTION_ADMIN, MySqlParserENCRYPTION_KEY_ADMIN, MySqlParserEXECUTE, MySqlParserFILE, MySqlParserFIREWALL_ADMIN, MySqlParserFIREWALL_EXEMPT, MySqlParserFIREWALL_USER, MySqlParserGROUP_REPLICATION_ADMIN, MySqlParserINNODB_REDO_LOG_ARCHIVE, MySqlParserINVOKE, MySqlParserLAMBDA, MySqlParserNDB_STORED_USER, MySqlParserPASSWORDLESS_USER_ADMIN, MySqlParserPERSIST_RO_VARIABLES_ADMIN, MySqlParserPRIVILEGES, MySqlParserPROCESS, MySqlParserRELOAD, MySqlParserREPLICATION_APPLIER, MySqlParserREPLICATION_SLAVE_ADMIN, MySqlParserRESOURCE_GROUP_ADMIN, MySqlParserRESOURCE_GROUP_USER, MySqlParserROLE_ADMIN, MySqlParserROUTINE, MySqlParserS3, MySqlParserSESSION_VARIABLES_ADMIN, MySqlParserSET_USER_ID, MySqlParserSHOW_ROUTINE, MySqlParserSHUTDOWN, MySqlParserSUPER, MySqlParserSYSTEM_VARIABLES_ADMIN, MySqlParserTABLES, MySqlParserTABLE_ENCRYPTION_ADMIN, MySqlParserVERSION_TOKEN_ADMIN, MySqlParserXA_RECOVER_ADMIN, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserARCHIVE, MySqlParserBLACKHOLE, MySqlParserCSV, MySqlParserFEDERATED, MySqlParserINNODB, MySqlParserMEMORY, MySqlParserMRG_MYISAM, MySqlParserMYISAM, MySqlParserNDB, MySqlParserNDBCLUSTER, MySqlParserPERFORMANCE_SCHEMA, MySqlParserTOKUDB, MySqlParserREPEATABLE, MySqlParserCOMMITTED, MySqlParserUNCOMMITTED, MySqlParserSERIALIZABLE, MySqlParserGEOMETRYCOLLECTION, MySqlParserLINESTRING, MySqlParserMULTILINESTRING, MySqlParserMULTIPOINT, MySqlParserMULTIPOLYGON, MySqlParserPOINT, MySqlParserPOLYGON, MySqlParserABS, MySqlParserACOS, MySqlParserADDDATE, MySqlParserADDTIME, MySqlParserAES_DECRYPT, MySqlParserAES_ENCRYPT, MySqlParserAREA, MySqlParserASBINARY, MySqlParserASIN, MySqlParserASTEXT, MySqlParserASWKB, MySqlParserASWKT, MySqlParserASYMMETRIC_DECRYPT, MySqlParserASYMMETRIC_DERIVE, MySqlParserASYMMETRIC_ENCRYPT, MySqlParserASYMMETRIC_SIGN, MySqlParserASYMMETRIC_VERIFY, MySqlParserATAN, MySqlParserATAN2, MySqlParserBENCHMARK, MySqlParserBIN, MySqlParserBIT_COUNT, MySqlParserBIT_LENGTH, MySqlParserBUFFER, MySqlParserCATALOG_NAME, MySqlParserCEIL, MySqlParserCEILING, MySqlParserCENTROID, MySqlParserCHARACTER_LENGTH, MySqlParserCHARSET, MySqlParserCHAR_LENGTH, MySqlParserCOERCIBILITY, MySqlParserCOLLATION, MySqlParserCOMPRESS, MySqlParserCONCAT, MySqlParserCONCAT_WS, MySqlParserCONNECTION_ID, MySqlParserCONV, MySqlParserCONVERT_TZ, MySqlParserCOS, MySqlParserCOT, MySqlParserCRC32, MySqlParserCREATE_ASYMMETRIC_PRIV_KEY, MySqlParserCREATE_ASYMMETRIC_PUB_KEY, MySqlParserCREATE_DH_PARAMETERS, MySqlParserCREATE_DIGEST, MySqlParserCROSSES, MySqlParserDATEDIFF, MySqlParserDATE_FORMAT, MySqlParserDAYNAME, MySqlParserDAYOFMONTH, MySqlParserDAYOFWEEK, MySqlParserDAYOFYEAR, MySqlParserDECODE, MySqlParserDEGREES, MySqlParserDES_DECRYPT, MySqlParserDES_ENCRYPT, MySqlParserDIMENSION, MySqlParserDISJOINT, MySqlParserDISTANCE, MySqlParserELT, MySqlParserENCODE, MySqlParserENCRYPT, MySqlParserENDPOINT, MySqlParserENGINE_ATTRIBUTE, MySqlParserENVELOPE, MySqlParserEQUALS, MySqlParserEXP, MySqlParserEXPORT_SET, MySqlParserEXTERIORRING, MySqlParserEXTRACTVALUE, MySqlParserFIELD, MySqlParserFIND_IN_SET, MySqlParserFLOOR, MySqlParserFORMAT, MySqlParserFOUND_ROWS, MySqlParserFROM_BASE64, MySqlParserFROM_DAYS, MySqlParserFROM_UNIXTIME, MySqlParserGEOMCOLLFROMTEXT, MySqlParserGEOMCOLLFROMWKB, MySqlParserGEOMETRYCOLLECTIONFROMTEXT, MySqlParserGEOMETRYCOLLECTIONFROMWKB, MySqlParserGEOMETRYFROMTEXT, MySqlParserGEOMETRYFROMWKB, MySqlParserGEOMETRYN, MySqlParserGEOMETRYTYPE, MySqlParserGEOMFROMTEXT, MySqlParserGEOMFROMWKB, MySqlParserGET_FORMAT, MySqlParserGET_LOCK, MySqlParserGLENGTH, MySqlParserGREATEST, MySqlParserGTID_SUBSET, MySqlParserGTID_SUBTRACT, MySqlParserHEX, MySqlParserIFNULL, MySqlParserINET6_ATON, MySqlParserINET6_NTOA, MySqlParserINET_ATON, MySqlParserINET_NTOA, MySqlParserINSTR, MySqlParserINTERIORRINGN, MySqlParserINTERSECTS, MySqlParserISCLOSED, MySqlParserISEMPTY, MySqlParserISNULL, MySqlParserISSIMPLE, MySqlParserIS_FREE_LOCK, MySqlParserIS_IPV4, MySqlParserIS_IPV4_COMPAT, MySqlParserIS_IPV4_MAPPED, MySqlParserIS_IPV6, MySqlParserIS_USED_LOCK, MySqlParserLAST_INSERT_ID, MySqlParserLCASE, MySqlParserLEAST, MySqlParserLENGTH, MySqlParserLINEFROMTEXT, MySqlParserLINEFROMWKB, MySqlParserLINESTRINGFROMTEXT, MySqlParserLINESTRINGFROMWKB, MySqlParserLN, MySqlParserLOAD_FILE, MySqlParserLOCATE, MySqlParserLOG, MySqlParserLOG10, MySqlParserLOG2, MySqlParserLOWER, MySqlParserLPAD, MySqlParserLTRIM, MySqlParserMAKEDATE, MySqlParserMAKETIME, MySqlParserMAKE_SET, MySqlParserMASTER_POS_WAIT, MySqlParserMBRCONTAINS, MySqlParserMBRDISJOINT, MySqlParserMBREQUAL, MySqlParserMBRINTERSECTS, MySqlParserMBROVERLAPS, MySqlParserMBRTOUCHES, MySqlParserMBRWITHIN, MySqlParserMD5, MySqlParserMLINEFROMTEXT, MySqlParserMLINEFROMWKB, MySqlParserMONTHNAME, MySqlParserMPOINTFROMTEXT, MySqlParserMPOINTFROMWKB, MySqlParserMPOLYFROMTEXT, MySqlParserMPOLYFROMWKB, MySqlParserMULTILINESTRINGFROMTEXT, MySqlParserMULTILINESTRINGFROMWKB, MySqlParserMULTIPOINTFROMTEXT, MySqlParserMULTIPOINTFROMWKB, MySqlParserMULTIPOLYGONFROMTEXT, MySqlParserMULTIPOLYGONFROMWKB, MySqlParserNAME_CONST, MySqlParserNULLIF, MySqlParserNUMGEOMETRIES, MySqlParserNUMINTERIORRINGS, MySqlParserNUMPOINTS, MySqlParserOCT, MySqlParserOCTET_LENGTH, MySqlParserORD, MySqlParserOVERLAPS, MySqlParserPERIOD_ADD, MySqlParserPERIOD_DIFF, MySqlParserPI, MySqlParserPOINTFROMTEXT, MySqlParserPOINTFROMWKB, MySqlParserPOINTN, MySqlParserPOLYFROMTEXT, MySqlParserPOLYFROMWKB, MySqlParserPOLYGONFROMTEXT, MySqlParserPOLYGONFROMWKB, MySqlParserPOW, MySqlParserPOWER, MySqlParserQUOTE, MySqlParserRADIANS, MySqlParserRAND, MySqlParserRANDOM, MySqlParserRANDOM_BYTES, MySqlParserRELEASE_LOCK, MySqlParserREVERSE, MySqlParserROUND, MySqlParserROW_COUNT, MySqlParserRPAD, MySqlParserRTRIM, MySqlParserSEC_TO_TIME, MySqlParserSECONDARY_ENGINE_ATTRIBUTE, MySqlParserSESSION_USER, MySqlParserSHA, MySqlParserSHA1, MySqlParserSHA2, MySqlParserSCHEMA_NAME, MySqlParserSIGN, MySqlParserSIN, MySqlParserSLEEP, MySqlParserSOUNDEX, MySqlParserSQL_THREAD_WAIT_AFTER_GTIDS, MySqlParserSQRT, MySqlParserSRID, MySqlParserSTARTPOINT, MySqlParserSTRCMP, MySqlParserSTR_TO_DATE, MySqlParserST_AREA, MySqlParserST_ASBINARY, MySqlParserST_ASTEXT, MySqlParserST_ASWKB, MySqlParserST_ASWKT, MySqlParserST_BUFFER, MySqlParserST_CENTROID, MySqlParserST_CONTAINS, MySqlParserST_CROSSES, MySqlParserST_DIFFERENCE, MySqlParserST_DIMENSION, MySqlParserST_DISJOINT, MySqlParserST_DISTANCE, MySqlParserST_ENDPOINT, MySqlParserST_ENVELOPE, MySqlParserST_EQUALS, MySqlParserST_EXTERIORRING, MySqlParserST_GEOMCOLLFROMTEXT, MySqlParserST_GEOMCOLLFROMTXT, MySqlParserST_GEOMCOLLFROMWKB, MySqlParserST_GEOMETRYCOLLECTIONFROMTEXT, MySqlParserST_GEOMETRYCOLLECTIONFROMWKB, MySqlParserST_GEOMETRYFROMTEXT, MySqlParserST_GEOMETRYFROMWKB, MySqlParserST_GEOMETRYN, MySqlParserST_GEOMETRYTYPE, MySqlParserST_GEOMFROMTEXT, MySqlParserST_GEOMFROMWKB, MySqlParserST_INTERIORRINGN, MySqlParserST_INTERSECTION, MySqlParserST_INTERSECTS, MySqlParserST_ISCLOSED, MySqlParserST_ISEMPTY, MySqlParserST_ISSIMPLE, MySqlParserST_LINEFROMTEXT, MySqlParserST_LINEFROMWKB, MySqlParserST_LINESTRINGFROMTEXT, MySqlParserST_LINESTRINGFROMWKB, MySqlParserST_NUMGEOMETRIES, MySqlParserST_NUMINTERIORRING, MySqlParserST_NUMINTERIORRINGS, MySqlParserST_NUMPOINTS, MySqlParserST_OVERLAPS, MySqlParserST_POINTFROMTEXT, MySqlParserST_POINTFROMWKB, MySqlParserST_POINTN, MySqlParserST_POLYFROMTEXT, MySqlParserST_POLYFROMWKB, MySqlParserST_POLYGONFROMTEXT, MySqlParserST_POLYGONFROMWKB, MySqlParserST_SRID, MySqlParserST_STARTPOINT, MySqlParserST_SYMDIFFERENCE, MySqlParserST_TOUCHES, MySqlParserST_UNION, MySqlParserST_WITHIN, MySqlParserST_X, MySqlParserST_Y, MySqlParserSTRING_TO_VECTOR, MySqlParserSUBDATE, MySqlParserSUBSTRING_INDEX, MySqlParserSUBTIME, MySqlParserSYSTEM_USER, MySqlParserTAN, MySqlParserTIMEDIFF, MySqlParserTIMESTAMPADD, MySqlParserTIMESTAMPDIFF, MySqlParserTIME_FORMAT, MySqlParserTIME_TO_SEC, MySqlParserTOUCHES, MySqlParserTO_BASE64, MySqlParserTO_DAYS, MySqlParserTO_SECONDS, MySqlParserTP_CONNECTION_ADMIN, MySqlParserUCASE, MySqlParserUNCOMPRESS, MySqlParserUNCOMPRESSED_LENGTH, MySqlParserUNHEX, MySqlParserUNIX_TIMESTAMP, MySqlParserUPDATEXML, MySqlParserUPPER, MySqlParserUUID, MySqlParserUUID_SHORT, MySqlParserVALIDATE_PASSWORD_STRENGTH, MySqlParserVECTOR_DIM, MySqlParserVECTOR_TO_STRING, MySqlParserVERSION, MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS, MySqlParserWEEKDAY, MySqlParserWEEKOFYEAR, MySqlParserWEIGHT_STRING, MySqlParserWITHIN, MySqlParserYEARWEEK, MySqlParserY_FUNCTION, MySqlParserX_FUNCTION, MySqlParserMOD, MySqlParserAT_SIGN, MySqlParserCHARSET_REVERSE_QOUTE_STRING, MySqlParserSTRING_LITERAL, MySqlParserID: + p.EnterOuterAlt(localctx, 3) + p.SetState(5949) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 869, p.GetParserRuleContext()) == 1 { + p.SetState(5946) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserAT_SIGN { + { + p.SetState(5944) + p.Match(MySqlParserAT_SIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5945) + p.Match(MySqlParserAT_SIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5948) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserGLOBAL || _la == MySqlParserLOCAL || _la == MySqlParserSESSION) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5951) + p.Uid() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShowCommonEntityContext is an interface to support dynamic dispatch. +type IShowCommonEntityContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHARACTER() antlr.TerminalNode + SET() antlr.TerminalNode + COLLATION() antlr.TerminalNode + DATABASES() antlr.TerminalNode + SCHEMAS() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + STATUS() antlr.TerminalNode + PROCEDURE() antlr.TerminalNode + VARIABLES() antlr.TerminalNode + GLOBAL() antlr.TerminalNode + SESSION() antlr.TerminalNode + + // IsShowCommonEntityContext differentiates from other interfaces. + IsShowCommonEntityContext() +} + +type ShowCommonEntityContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShowCommonEntityContext() *ShowCommonEntityContext { + var p = new(ShowCommonEntityContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_showCommonEntity + return p +} + +func InitEmptyShowCommonEntityContext(p *ShowCommonEntityContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_showCommonEntity +} + +func (*ShowCommonEntityContext) IsShowCommonEntityContext() {} + +func NewShowCommonEntityContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ShowCommonEntityContext { + var p = new(ShowCommonEntityContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_showCommonEntity + + return p +} + +func (s *ShowCommonEntityContext) GetParser() antlr.Parser { return s.parser } + +func (s *ShowCommonEntityContext) CHARACTER() antlr.TerminalNode { + return s.GetToken(MySqlParserCHARACTER, 0) +} + +func (s *ShowCommonEntityContext) SET() antlr.TerminalNode { + return s.GetToken(MySqlParserSET, 0) +} + +func (s *ShowCommonEntityContext) COLLATION() antlr.TerminalNode { + return s.GetToken(MySqlParserCOLLATION, 0) +} + +func (s *ShowCommonEntityContext) DATABASES() antlr.TerminalNode { + return s.GetToken(MySqlParserDATABASES, 0) +} + +func (s *ShowCommonEntityContext) SCHEMAS() antlr.TerminalNode { + return s.GetToken(MySqlParserSCHEMAS, 0) +} + +func (s *ShowCommonEntityContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(MySqlParserFUNCTION, 0) +} + +func (s *ShowCommonEntityContext) STATUS() antlr.TerminalNode { + return s.GetToken(MySqlParserSTATUS, 0) +} + +func (s *ShowCommonEntityContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(MySqlParserPROCEDURE, 0) +} + +func (s *ShowCommonEntityContext) VARIABLES() antlr.TerminalNode { + return s.GetToken(MySqlParserVARIABLES, 0) +} + +func (s *ShowCommonEntityContext) GLOBAL() antlr.TerminalNode { + return s.GetToken(MySqlParserGLOBAL, 0) +} + +func (s *ShowCommonEntityContext) SESSION() antlr.TerminalNode { + return s.GetToken(MySqlParserSESSION, 0) +} + +func (s *ShowCommonEntityContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowCommonEntityContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ShowCommonEntityContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterShowCommonEntity(s) + } +} + +func (s *ShowCommonEntityContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitShowCommonEntity(s) + } +} + +func (p *MySqlParser) ShowCommonEntity() (localctx IShowCommonEntityContext) { + localctx = NewShowCommonEntityContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 494, MySqlParserRULE_showCommonEntity) + var _la int + + p.SetState(5967) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserCHARACTER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5954) + p.Match(MySqlParserCHARACTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5955) + p.Match(MySqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserCOLLATION: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5956) + p.Match(MySqlParserCOLLATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserDATABASES: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5957) + p.Match(MySqlParserDATABASES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserSCHEMAS: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5958) + p.Match(MySqlParserSCHEMAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserFUNCTION: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(5959) + p.Match(MySqlParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5960) + p.Match(MySqlParserSTATUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserPROCEDURE: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(5961) + p.Match(MySqlParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5962) + p.Match(MySqlParserSTATUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserGLOBAL, MySqlParserSESSION, MySqlParserSTATUS, MySqlParserVARIABLES: + p.EnterOuterAlt(localctx, 7) + p.SetState(5964) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserGLOBAL || _la == MySqlParserSESSION { + { + p.SetState(5963) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserGLOBAL || _la == MySqlParserSESSION) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(5966) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserSTATUS || _la == MySqlParserVARIABLES) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShowFilterContext is an interface to support dynamic dispatch. +type IShowFilterContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LIKE() antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + WHERE() antlr.TerminalNode + Expression() IExpressionContext + + // IsShowFilterContext differentiates from other interfaces. + IsShowFilterContext() +} + +type ShowFilterContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShowFilterContext() *ShowFilterContext { + var p = new(ShowFilterContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_showFilter + return p +} + +func InitEmptyShowFilterContext(p *ShowFilterContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_showFilter +} + +func (*ShowFilterContext) IsShowFilterContext() {} + +func NewShowFilterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ShowFilterContext { + var p = new(ShowFilterContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_showFilter + + return p +} + +func (s *ShowFilterContext) GetParser() antlr.Parser { return s.parser } + +func (s *ShowFilterContext) LIKE() antlr.TerminalNode { + return s.GetToken(MySqlParserLIKE, 0) +} + +func (s *ShowFilterContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *ShowFilterContext) WHERE() antlr.TerminalNode { + return s.GetToken(MySqlParserWHERE, 0) +} + +func (s *ShowFilterContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *ShowFilterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowFilterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ShowFilterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterShowFilter(s) + } +} + +func (s *ShowFilterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitShowFilter(s) + } +} + +func (p *MySqlParser) ShowFilter() (localctx IShowFilterContext) { + localctx = NewShowFilterContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 496, MySqlParserRULE_showFilter) + p.SetState(5973) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserLIKE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5969) + p.Match(MySqlParserLIKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5970) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserWHERE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5971) + p.Match(MySqlParserWHERE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5972) + p.expression(0) + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShowGlobalInfoClauseContext is an interface to support dynamic dispatch. +type IShowGlobalInfoClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ENGINES() antlr.TerminalNode + STORAGE() antlr.TerminalNode + MASTER() antlr.TerminalNode + STATUS() antlr.TerminalNode + PLUGINS() antlr.TerminalNode + PRIVILEGES() antlr.TerminalNode + PROCESSLIST() antlr.TerminalNode + FULL() antlr.TerminalNode + PROFILES() antlr.TerminalNode + SLAVE() antlr.TerminalNode + HOSTS() antlr.TerminalNode + AUTHORS() antlr.TerminalNode + CONTRIBUTORS() antlr.TerminalNode + + // IsShowGlobalInfoClauseContext differentiates from other interfaces. + IsShowGlobalInfoClauseContext() +} + +type ShowGlobalInfoClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShowGlobalInfoClauseContext() *ShowGlobalInfoClauseContext { + var p = new(ShowGlobalInfoClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_showGlobalInfoClause + return p +} + +func InitEmptyShowGlobalInfoClauseContext(p *ShowGlobalInfoClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_showGlobalInfoClause +} + +func (*ShowGlobalInfoClauseContext) IsShowGlobalInfoClauseContext() {} + +func NewShowGlobalInfoClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ShowGlobalInfoClauseContext { + var p = new(ShowGlobalInfoClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_showGlobalInfoClause + + return p +} + +func (s *ShowGlobalInfoClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *ShowGlobalInfoClauseContext) ENGINES() antlr.TerminalNode { + return s.GetToken(MySqlParserENGINES, 0) +} + +func (s *ShowGlobalInfoClauseContext) STORAGE() antlr.TerminalNode { + return s.GetToken(MySqlParserSTORAGE, 0) +} + +func (s *ShowGlobalInfoClauseContext) MASTER() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER, 0) +} + +func (s *ShowGlobalInfoClauseContext) STATUS() antlr.TerminalNode { + return s.GetToken(MySqlParserSTATUS, 0) +} + +func (s *ShowGlobalInfoClauseContext) PLUGINS() antlr.TerminalNode { + return s.GetToken(MySqlParserPLUGINS, 0) +} + +func (s *ShowGlobalInfoClauseContext) PRIVILEGES() antlr.TerminalNode { + return s.GetToken(MySqlParserPRIVILEGES, 0) +} + +func (s *ShowGlobalInfoClauseContext) PROCESSLIST() antlr.TerminalNode { + return s.GetToken(MySqlParserPROCESSLIST, 0) +} + +func (s *ShowGlobalInfoClauseContext) FULL() antlr.TerminalNode { + return s.GetToken(MySqlParserFULL, 0) +} + +func (s *ShowGlobalInfoClauseContext) PROFILES() antlr.TerminalNode { + return s.GetToken(MySqlParserPROFILES, 0) +} + +func (s *ShowGlobalInfoClauseContext) SLAVE() antlr.TerminalNode { + return s.GetToken(MySqlParserSLAVE, 0) +} + +func (s *ShowGlobalInfoClauseContext) HOSTS() antlr.TerminalNode { + return s.GetToken(MySqlParserHOSTS, 0) +} + +func (s *ShowGlobalInfoClauseContext) AUTHORS() antlr.TerminalNode { + return s.GetToken(MySqlParserAUTHORS, 0) +} + +func (s *ShowGlobalInfoClauseContext) CONTRIBUTORS() antlr.TerminalNode { + return s.GetToken(MySqlParserCONTRIBUTORS, 0) +} + +func (s *ShowGlobalInfoClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowGlobalInfoClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ShowGlobalInfoClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterShowGlobalInfoClause(s) + } +} + +func (s *ShowGlobalInfoClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitShowGlobalInfoClause(s) + } +} + +func (p *MySqlParser) ShowGlobalInfoClause() (localctx IShowGlobalInfoClauseContext) { + localctx = NewShowGlobalInfoClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 498, MySqlParserRULE_showGlobalInfoClause) + var _la int + + p.SetState(5992) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserENGINES, MySqlParserSTORAGE: + p.EnterOuterAlt(localctx, 1) + p.SetState(5976) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserSTORAGE { + { + p.SetState(5975) + p.Match(MySqlParserSTORAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5978) + p.Match(MySqlParserENGINES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserMASTER: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5979) + p.Match(MySqlParserMASTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5980) + p.Match(MySqlParserSTATUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserPLUGINS: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5981) + p.Match(MySqlParserPLUGINS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserPRIVILEGES: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5982) + p.Match(MySqlParserPRIVILEGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserFULL, MySqlParserPROCESSLIST: + p.EnterOuterAlt(localctx, 5) + p.SetState(5984) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserFULL { + { + p.SetState(5983) + p.Match(MySqlParserFULL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5986) + p.Match(MySqlParserPROCESSLIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserPROFILES: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(5987) + p.Match(MySqlParserPROFILES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserSLAVE: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(5988) + p.Match(MySqlParserSLAVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5989) + p.Match(MySqlParserHOSTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserAUTHORS: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(5990) + p.Match(MySqlParserAUTHORS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserCONTRIBUTORS: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(5991) + p.Match(MySqlParserCONTRIBUTORS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShowSchemaEntityContext is an interface to support dynamic dispatch. +type IShowSchemaEntityContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EVENTS() antlr.TerminalNode + TABLE() antlr.TerminalNode + STATUS() antlr.TerminalNode + TABLES() antlr.TerminalNode + FULL() antlr.TerminalNode + TRIGGERS() antlr.TerminalNode + + // IsShowSchemaEntityContext differentiates from other interfaces. + IsShowSchemaEntityContext() +} + +type ShowSchemaEntityContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShowSchemaEntityContext() *ShowSchemaEntityContext { + var p = new(ShowSchemaEntityContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_showSchemaEntity + return p +} + +func InitEmptyShowSchemaEntityContext(p *ShowSchemaEntityContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_showSchemaEntity +} + +func (*ShowSchemaEntityContext) IsShowSchemaEntityContext() {} + +func NewShowSchemaEntityContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ShowSchemaEntityContext { + var p = new(ShowSchemaEntityContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_showSchemaEntity + + return p +} + +func (s *ShowSchemaEntityContext) GetParser() antlr.Parser { return s.parser } + +func (s *ShowSchemaEntityContext) EVENTS() antlr.TerminalNode { + return s.GetToken(MySqlParserEVENTS, 0) +} + +func (s *ShowSchemaEntityContext) TABLE() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLE, 0) +} + +func (s *ShowSchemaEntityContext) STATUS() antlr.TerminalNode { + return s.GetToken(MySqlParserSTATUS, 0) +} + +func (s *ShowSchemaEntityContext) TABLES() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLES, 0) +} + +func (s *ShowSchemaEntityContext) FULL() antlr.TerminalNode { + return s.GetToken(MySqlParserFULL, 0) +} + +func (s *ShowSchemaEntityContext) TRIGGERS() antlr.TerminalNode { + return s.GetToken(MySqlParserTRIGGERS, 0) +} + +func (s *ShowSchemaEntityContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowSchemaEntityContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ShowSchemaEntityContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterShowSchemaEntity(s) + } +} + +func (s *ShowSchemaEntityContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitShowSchemaEntity(s) + } +} + +func (p *MySqlParser) ShowSchemaEntity() (localctx IShowSchemaEntityContext) { + localctx = NewShowSchemaEntityContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 500, MySqlParserRULE_showSchemaEntity) + var _la int + + p.SetState(6002) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserEVENTS: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5994) + p.Match(MySqlParserEVENTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserTABLE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5995) + p.Match(MySqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5996) + p.Match(MySqlParserSTATUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserFULL, MySqlParserTABLES: + p.EnterOuterAlt(localctx, 3) + p.SetState(5998) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserFULL { + { + p.SetState(5997) + p.Match(MySqlParserFULL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6000) + p.Match(MySqlParserTABLES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserTRIGGERS: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(6001) + p.Match(MySqlParserTRIGGERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShowProfileTypeContext is an interface to support dynamic dispatch. +type IShowProfileTypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALL() antlr.TerminalNode + BLOCK() antlr.TerminalNode + IO() antlr.TerminalNode + CONTEXT() antlr.TerminalNode + SWITCHES() antlr.TerminalNode + CPU() antlr.TerminalNode + IPC() antlr.TerminalNode + MEMORY() antlr.TerminalNode + PAGE() antlr.TerminalNode + FAULTS() antlr.TerminalNode + SOURCE() antlr.TerminalNode + SWAPS() antlr.TerminalNode + + // IsShowProfileTypeContext differentiates from other interfaces. + IsShowProfileTypeContext() +} + +type ShowProfileTypeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShowProfileTypeContext() *ShowProfileTypeContext { + var p = new(ShowProfileTypeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_showProfileType + return p +} + +func InitEmptyShowProfileTypeContext(p *ShowProfileTypeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_showProfileType +} + +func (*ShowProfileTypeContext) IsShowProfileTypeContext() {} + +func NewShowProfileTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ShowProfileTypeContext { + var p = new(ShowProfileTypeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_showProfileType + + return p +} + +func (s *ShowProfileTypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *ShowProfileTypeContext) ALL() antlr.TerminalNode { + return s.GetToken(MySqlParserALL, 0) +} + +func (s *ShowProfileTypeContext) BLOCK() antlr.TerminalNode { + return s.GetToken(MySqlParserBLOCK, 0) +} + +func (s *ShowProfileTypeContext) IO() antlr.TerminalNode { + return s.GetToken(MySqlParserIO, 0) +} + +func (s *ShowProfileTypeContext) CONTEXT() antlr.TerminalNode { + return s.GetToken(MySqlParserCONTEXT, 0) +} + +func (s *ShowProfileTypeContext) SWITCHES() antlr.TerminalNode { + return s.GetToken(MySqlParserSWITCHES, 0) +} + +func (s *ShowProfileTypeContext) CPU() antlr.TerminalNode { + return s.GetToken(MySqlParserCPU, 0) +} + +func (s *ShowProfileTypeContext) IPC() antlr.TerminalNode { + return s.GetToken(MySqlParserIPC, 0) +} + +func (s *ShowProfileTypeContext) MEMORY() antlr.TerminalNode { + return s.GetToken(MySqlParserMEMORY, 0) +} + +func (s *ShowProfileTypeContext) PAGE() antlr.TerminalNode { + return s.GetToken(MySqlParserPAGE, 0) +} + +func (s *ShowProfileTypeContext) FAULTS() antlr.TerminalNode { + return s.GetToken(MySqlParserFAULTS, 0) +} + +func (s *ShowProfileTypeContext) SOURCE() antlr.TerminalNode { + return s.GetToken(MySqlParserSOURCE, 0) +} + +func (s *ShowProfileTypeContext) SWAPS() antlr.TerminalNode { + return s.GetToken(MySqlParserSWAPS, 0) +} + +func (s *ShowProfileTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowProfileTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ShowProfileTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterShowProfileType(s) + } +} + +func (s *ShowProfileTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitShowProfileType(s) + } +} + +func (p *MySqlParser) ShowProfileType() (localctx IShowProfileTypeContext) { + localctx = NewShowProfileTypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 502, MySqlParserRULE_showProfileType) + p.SetState(6016) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserALL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6004) + p.Match(MySqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserBLOCK: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6005) + p.Match(MySqlParserBLOCK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6006) + p.Match(MySqlParserIO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserCONTEXT: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6007) + p.Match(MySqlParserCONTEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6008) + p.Match(MySqlParserSWITCHES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserCPU: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(6009) + p.Match(MySqlParserCPU) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserIPC: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(6010) + p.Match(MySqlParserIPC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserMEMORY: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(6011) + p.Match(MySqlParserMEMORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserPAGE: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(6012) + p.Match(MySqlParserPAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6013) + p.Match(MySqlParserFAULTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserSOURCE: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(6014) + p.Match(MySqlParserSOURCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserSWAPS: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(6015) + p.Match(MySqlParserSWAPS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBinlogStatementContext is an interface to support dynamic dispatch. +type IBinlogStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BINLOG() antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + + // IsBinlogStatementContext differentiates from other interfaces. + IsBinlogStatementContext() +} + +type BinlogStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBinlogStatementContext() *BinlogStatementContext { + var p = new(BinlogStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_binlogStatement + return p +} + +func InitEmptyBinlogStatementContext(p *BinlogStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_binlogStatement +} + +func (*BinlogStatementContext) IsBinlogStatementContext() {} + +func NewBinlogStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BinlogStatementContext { + var p = new(BinlogStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_binlogStatement + + return p +} + +func (s *BinlogStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *BinlogStatementContext) BINLOG() antlr.TerminalNode { + return s.GetToken(MySqlParserBINLOG, 0) +} + +func (s *BinlogStatementContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *BinlogStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *BinlogStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *BinlogStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterBinlogStatement(s) + } +} + +func (s *BinlogStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitBinlogStatement(s) + } +} + +func (p *MySqlParser) BinlogStatement() (localctx IBinlogStatementContext) { + localctx = NewBinlogStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 504, MySqlParserRULE_binlogStatement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6018) + p.Match(MySqlParserBINLOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6019) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICacheIndexStatementContext is an interface to support dynamic dispatch. +type ICacheIndexStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetSchema returns the schema rule contexts. + GetSchema() IUidContext + + // SetSchema sets the schema rule contexts. + SetSchema(IUidContext) + + // Getter signatures + CACHE() antlr.TerminalNode + INDEX() antlr.TerminalNode + AllTableIndexes() []ITableIndexesContext + TableIndexes(i int) ITableIndexesContext + IN() antlr.TerminalNode + Uid() IUidContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + PARTITION() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + UidList() IUidListContext + ALL() antlr.TerminalNode + + // IsCacheIndexStatementContext differentiates from other interfaces. + IsCacheIndexStatementContext() +} + +type CacheIndexStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + schema IUidContext +} + +func NewEmptyCacheIndexStatementContext() *CacheIndexStatementContext { + var p = new(CacheIndexStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_cacheIndexStatement + return p +} + +func InitEmptyCacheIndexStatementContext(p *CacheIndexStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_cacheIndexStatement +} + +func (*CacheIndexStatementContext) IsCacheIndexStatementContext() {} + +func NewCacheIndexStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CacheIndexStatementContext { + var p = new(CacheIndexStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_cacheIndexStatement + + return p +} + +func (s *CacheIndexStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *CacheIndexStatementContext) GetSchema() IUidContext { return s.schema } + +func (s *CacheIndexStatementContext) SetSchema(v IUidContext) { s.schema = v } + +func (s *CacheIndexStatementContext) CACHE() antlr.TerminalNode { + return s.GetToken(MySqlParserCACHE, 0) +} + +func (s *CacheIndexStatementContext) INDEX() antlr.TerminalNode { + return s.GetToken(MySqlParserINDEX, 0) +} + +func (s *CacheIndexStatementContext) AllTableIndexes() []ITableIndexesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITableIndexesContext); ok { + len++ + } + } + + tst := make([]ITableIndexesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITableIndexesContext); ok { + tst[i] = t.(ITableIndexesContext) + i++ + } + } + + return tst +} + +func (s *CacheIndexStatementContext) TableIndexes(i int) ITableIndexesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableIndexesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITableIndexesContext) +} + +func (s *CacheIndexStatementContext) IN() antlr.TerminalNode { + return s.GetToken(MySqlParserIN, 0) +} + +func (s *CacheIndexStatementContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *CacheIndexStatementContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *CacheIndexStatementContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *CacheIndexStatementContext) PARTITION() antlr.TerminalNode { + return s.GetToken(MySqlParserPARTITION, 0) +} + +func (s *CacheIndexStatementContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *CacheIndexStatementContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *CacheIndexStatementContext) UidList() IUidListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidListContext) +} + +func (s *CacheIndexStatementContext) ALL() antlr.TerminalNode { + return s.GetToken(MySqlParserALL, 0) +} + +func (s *CacheIndexStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CacheIndexStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CacheIndexStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCacheIndexStatement(s) + } +} + +func (s *CacheIndexStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCacheIndexStatement(s) + } +} + +func (p *MySqlParser) CacheIndexStatement() (localctx ICacheIndexStatementContext) { + localctx = NewCacheIndexStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 506, MySqlParserRULE_cacheIndexStatement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6021) + p.Match(MySqlParserCACHE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6022) + p.Match(MySqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6023) + p.TableIndexes() + } + p.SetState(6028) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(6024) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6025) + p.TableIndexes() + } + + p.SetState(6030) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(6038) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserPARTITION { + { + p.SetState(6031) + p.Match(MySqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6032) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6035) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserARRAY, MySqlParserATTRIBUTE, MySqlParserBUCKETS, MySqlParserCONDITION, MySqlParserCURRENT, MySqlParserCURRENT_USER, MySqlParserDATABASE, MySqlParserDEFAULT, MySqlParserDIAGNOSTICS, MySqlParserEMPTY, MySqlParserENFORCED, MySqlParserEXCEPT, MySqlParserGROUP, MySqlParserIF, MySqlParserIGNORED, MySqlParserINSERT, MySqlParserLATERAL, MySqlParserLEFT, MySqlParserNUMBER, MySqlParserOPTIONAL, MySqlParserORDER, MySqlParserPRIMARY, MySqlParserREPEAT, MySqlParserREPLACE, MySqlParserRIGHT, MySqlParserSCHEMA, MySqlParserSKIP_QUERY_REWRITE, MySqlParserSTACKED, MySqlParserSTATEMENT, MySqlParserDATE, MySqlParserTIME, MySqlParserTIMESTAMP, MySqlParserDATETIME, MySqlParserYEAR, MySqlParserBINARY, MySqlParserTEXT, MySqlParserENUM, MySqlParserSERIAL, MySqlParserJSON_ARRAY, MySqlParserJSON_ARRAYAGG, MySqlParserJSON_ARRAY_APPEND, MySqlParserJSON_ARRAY_INSERT, MySqlParserJSON_CONTAINS, MySqlParserJSON_CONTAINS_PATH, MySqlParserJSON_DEPTH, MySqlParserJSON_EXTRACT, MySqlParserJSON_INSERT, MySqlParserJSON_KEYS, MySqlParserJSON_LENGTH, MySqlParserJSON_MERGE, MySqlParserJSON_MERGE_PATCH, MySqlParserJSON_MERGE_PRESERVE, MySqlParserJSON_OBJECT, MySqlParserJSON_OBJECTAGG, MySqlParserJSON_OVERLAPS, MySqlParserJSON_PRETTY, MySqlParserJSON_QUOTE, MySqlParserJSON_REMOVE, MySqlParserJSON_REPLACE, MySqlParserJSON_SCHEMA_VALID, MySqlParserJSON_SCHEMA_VALIDATION_REPORT, MySqlParserJSON_SEARCH, MySqlParserJSON_SET, MySqlParserJSON_STORAGE_FREE, MySqlParserJSON_STORAGE_SIZE, MySqlParserJSON_TABLE, MySqlParserJSON_TYPE, MySqlParserJSON_UNQUOTE, MySqlParserJSON_VALID, MySqlParserJSON_VALUE, MySqlParserNESTED, MySqlParserORDINALITY, MySqlParserPATH, MySqlParserAVG, MySqlParserBIT_AND, MySqlParserBIT_OR, MySqlParserBIT_XOR, MySqlParserCOUNT, MySqlParserCUME_DIST, MySqlParserDENSE_RANK, MySqlParserFIRST_VALUE, MySqlParserGROUP_CONCAT, MySqlParserLAG, MySqlParserLAST_VALUE, MySqlParserLEAD, MySqlParserMAX, MySqlParserMIN, MySqlParserNTILE, MySqlParserNTH_VALUE, MySqlParserPERCENT_RANK, MySqlParserRANK, MySqlParserROW_NUMBER, MySqlParserSTD, MySqlParserSTDDEV, MySqlParserSTDDEV_POP, MySqlParserSTDDEV_SAMP, MySqlParserSUM, MySqlParserVAR_POP, MySqlParserVAR_SAMP, MySqlParserVARIANCE, MySqlParserCURRENT_DATE, MySqlParserCURRENT_TIME, MySqlParserCURRENT_TIMESTAMP, MySqlParserLOCALTIME, MySqlParserCURDATE, MySqlParserCURTIME, MySqlParserDATE_ADD, MySqlParserDATE_SUB, MySqlParserLOCALTIMESTAMP, MySqlParserNOW, MySqlParserPOSITION, MySqlParserSUBSTR, MySqlParserSUBSTRING, MySqlParserSYSDATE, MySqlParserTRIM, MySqlParserUTC_DATE, MySqlParserUTC_TIME, MySqlParserUTC_TIMESTAMP, MySqlParserACCOUNT, MySqlParserACTION, MySqlParserAFTER, MySqlParserAGGREGATE, MySqlParserALGORITHM, MySqlParserANY, MySqlParserAT, MySqlParserAUTHORS, MySqlParserAUTOCOMMIT, MySqlParserAUTOEXTEND_SIZE, MySqlParserAUTO_INCREMENT, MySqlParserAVG_ROW_LENGTH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserBIT, MySqlParserBLOCK, MySqlParserBOOL, MySqlParserBOOLEAN, MySqlParserBTREE, MySqlParserCACHE, MySqlParserCASCADED, MySqlParserCHAIN, MySqlParserCHANGED, MySqlParserCHANNEL, MySqlParserCHECKSUM, MySqlParserPAGE_CHECKSUM, MySqlParserCIPHER, MySqlParserCLASS_ORIGIN, MySqlParserCLIENT, MySqlParserCLOSE, MySqlParserCLUSTERING, MySqlParserCOALESCE, MySqlParserCODE, MySqlParserCOLUMNS, MySqlParserCOLUMN_FORMAT, MySqlParserCOLUMN_NAME, MySqlParserCOMMENT, MySqlParserCOMMIT, MySqlParserCOMPACT, MySqlParserCOMPLETION, MySqlParserCOMPRESSED, MySqlParserCOMPRESSION, MySqlParserCONCURRENT, MySqlParserCONNECT, MySqlParserCONNECTION, MySqlParserCONSISTENT, MySqlParserCONSTRAINT_CATALOG, MySqlParserCONSTRAINT_SCHEMA, MySqlParserCONSTRAINT_NAME, MySqlParserCONTAINS, MySqlParserCONTEXT, MySqlParserCONTRIBUTORS, MySqlParserCOPY, MySqlParserCPU, MySqlParserCURSOR_NAME, MySqlParserDATA, MySqlParserDATAFILE, MySqlParserDEALLOCATE, MySqlParserDEFAULT_AUTH, MySqlParserDEFINER, MySqlParserDELAY_KEY_WRITE, MySqlParserDES_KEY_FILE, MySqlParserDIRECTORY, MySqlParserDISABLE, MySqlParserDISCARD, MySqlParserDISK, MySqlParserDO, MySqlParserDUMPFILE, MySqlParserDUPLICATE, MySqlParserDYNAMIC, MySqlParserENABLE, MySqlParserENCRYPTION, MySqlParserEND, MySqlParserENDS, MySqlParserENGINE, MySqlParserENGINES, MySqlParserERROR, MySqlParserERRORS, MySqlParserESCAPE, MySqlParserEVEN, MySqlParserEVENT, MySqlParserEVENTS, MySqlParserEVERY, MySqlParserEXCHANGE, MySqlParserEXCLUSIVE, MySqlParserEXPIRE, MySqlParserEXPORT, MySqlParserEXTENDED, MySqlParserEXTENT_SIZE, MySqlParserFAILED_LOGIN_ATTEMPTS, MySqlParserFAST, MySqlParserFAULTS, MySqlParserFIELDS, MySqlParserFILE_BLOCK_SIZE, MySqlParserFILTER, MySqlParserFIRST, MySqlParserFIXED, MySqlParserFLUSH, MySqlParserFOLLOWS, MySqlParserFOUND, MySqlParserFULL, MySqlParserFUNCTION, MySqlParserGENERAL, MySqlParserGLOBAL, MySqlParserGRANTS, MySqlParserGROUP_REPLICATION, MySqlParserHANDLER, MySqlParserHASH, MySqlParserHELP, MySqlParserHISTORY, MySqlParserHOST, MySqlParserHOSTS, MySqlParserIDENTIFIED, MySqlParserIGNORE_SERVER_IDS, MySqlParserIMPORT, MySqlParserINDEXES, MySqlParserINITIAL_SIZE, MySqlParserINPLACE, MySqlParserINSERT_METHOD, MySqlParserINSTALL, MySqlParserINSTANCE, MySqlParserINSTANT, MySqlParserINVISIBLE, MySqlParserINVOKER, MySqlParserIO, MySqlParserIO_THREAD, MySqlParserIPC, MySqlParserISOLATION, MySqlParserISSUER, MySqlParserJSON, MySqlParserKEY_BLOCK_SIZE, MySqlParserLANGUAGE, MySqlParserLAST, MySqlParserLEAVES, MySqlParserLESS, MySqlParserLEVEL, MySqlParserLIST, MySqlParserLOCAL, MySqlParserLOGFILE, MySqlParserLOGS, MySqlParserMASTER, MySqlParserMASTER_AUTO_POSITION, MySqlParserMASTER_CONNECT_RETRY, MySqlParserMASTER_DELAY, MySqlParserMASTER_HEARTBEAT_PERIOD, MySqlParserMASTER_HOST, MySqlParserMASTER_LOG_FILE, MySqlParserMASTER_LOG_POS, MySqlParserMASTER_PASSWORD, MySqlParserMASTER_PORT, MySqlParserMASTER_RETRY_COUNT, MySqlParserMASTER_SSL, MySqlParserMASTER_SSL_CA, MySqlParserMASTER_SSL_CAPATH, MySqlParserMASTER_SSL_CERT, MySqlParserMASTER_SSL_CIPHER, MySqlParserMASTER_SSL_CRL, MySqlParserMASTER_SSL_CRLPATH, MySqlParserMASTER_SSL_KEY, MySqlParserMASTER_TLS_VERSION, MySqlParserMASTER_USER, MySqlParserMAX_CONNECTIONS_PER_HOUR, MySqlParserMAX_QUERIES_PER_HOUR, MySqlParserMAX_ROWS, MySqlParserMAX_SIZE, MySqlParserMAX_UPDATES_PER_HOUR, MySqlParserMAX_USER_CONNECTIONS, MySqlParserMEDIUM, MySqlParserMEMBER, MySqlParserMERGE, MySqlParserMESSAGE_TEXT, MySqlParserMID, MySqlParserMIGRATE, MySqlParserMIN_ROWS, MySqlParserMODE, MySqlParserMODIFY, MySqlParserMUTEX, MySqlParserMYSQL, MySqlParserMYSQL_ERRNO, MySqlParserNAME, MySqlParserNAMES, MySqlParserNCHAR, MySqlParserNEVER, MySqlParserNEXT, MySqlParserNO, MySqlParserNOCOPY, MySqlParserNOWAIT, MySqlParserNODEGROUP, MySqlParserNONE, MySqlParserODBC, MySqlParserOFFLINE, MySqlParserOFFSET, MySqlParserOF, MySqlParserOJ, MySqlParserOLD_PASSWORD, MySqlParserONE, MySqlParserONLINE, MySqlParserONLY, MySqlParserOPEN, MySqlParserOPTIMIZER_COSTS, MySqlParserOPTIONS, MySqlParserOWNER, MySqlParserPACK_KEYS, MySqlParserPAGE, MySqlParserPARSER, MySqlParserPARTIAL, MySqlParserPARTITIONING, MySqlParserPARTITIONS, MySqlParserPASSWORD, MySqlParserPASSWORD_LOCK_TIME, MySqlParserPHASE, MySqlParserPLUGIN, MySqlParserPLUGIN_DIR, MySqlParserPLUGINS, MySqlParserPORT, MySqlParserPRECEDES, MySqlParserPREPARE, MySqlParserPRESERVE, MySqlParserPREV, MySqlParserPROCESSLIST, MySqlParserPROFILE, MySqlParserPROFILES, MySqlParserPROXY, MySqlParserQUERY, MySqlParserQUICK, MySqlParserREBUILD, MySqlParserRECOVER, MySqlParserRECURSIVE, MySqlParserREDO_BUFFER_SIZE, MySqlParserREDUNDANT, MySqlParserRELAY, MySqlParserRELAY_LOG_FILE, MySqlParserRELAY_LOG_POS, MySqlParserRELAYLOG, MySqlParserREMOVE, MySqlParserREORGANIZE, MySqlParserREPAIR, MySqlParserREPLICATE_DO_DB, MySqlParserREPLICATE_DO_TABLE, MySqlParserREPLICATE_IGNORE_DB, MySqlParserREPLICATE_IGNORE_TABLE, MySqlParserREPLICATE_REWRITE_DB, MySqlParserREPLICATE_WILD_DO_TABLE, MySqlParserREPLICATE_WILD_IGNORE_TABLE, MySqlParserREPLICATION, MySqlParserRESET, MySqlParserRESUME, MySqlParserRETURNED_SQLSTATE, MySqlParserRETURNING, MySqlParserRETURNS, MySqlParserREUSE, MySqlParserROLE, MySqlParserROLLBACK, MySqlParserROLLUP, MySqlParserROTATE, MySqlParserROW, MySqlParserROWS, MySqlParserROW_FORMAT, MySqlParserRTREE, MySqlParserSAVEPOINT, MySqlParserSCHEDULE, MySqlParserSECURITY, MySqlParserSERVER, MySqlParserSESSION, MySqlParserSHARE, MySqlParserSHARED, MySqlParserSIGNED, MySqlParserSIMPLE, MySqlParserSLAVE, MySqlParserSLOW, MySqlParserSNAPSHOT, MySqlParserSOCKET, MySqlParserSOME, MySqlParserSONAME, MySqlParserSOUNDS, MySqlParserSOURCE, MySqlParserSQL_AFTER_GTIDS, MySqlParserSQL_AFTER_MTS_GAPS, MySqlParserSQL_BEFORE_GTIDS, MySqlParserSQL_BUFFER_RESULT, MySqlParserSQL_CACHE, MySqlParserSQL_NO_CACHE, MySqlParserSQL_THREAD, MySqlParserSTART, MySqlParserSTARTS, MySqlParserSTATS_AUTO_RECALC, MySqlParserSTATS_PERSISTENT, MySqlParserSTATS_SAMPLE_PAGES, MySqlParserSTATUS, MySqlParserSTOP, MySqlParserSTORAGE, MySqlParserSTRING, MySqlParserSUBCLASS_ORIGIN, MySqlParserSUBJECT, MySqlParserSUBPARTITION, MySqlParserSUBPARTITIONS, MySqlParserSUSPEND, MySqlParserSWAPS, MySqlParserSWITCHES, MySqlParserTABLE_NAME, MySqlParserTABLESPACE, MySqlParserTABLE_TYPE, MySqlParserTEMPORARY, MySqlParserTEMPTABLE, MySqlParserTHAN, MySqlParserTRADITIONAL, MySqlParserTRANSACTION, MySqlParserTRANSACTIONAL, MySqlParserTRIGGERS, MySqlParserTRUNCATE, MySqlParserUNBOUNDED, MySqlParserUNDEFINED, MySqlParserUNDOFILE, MySqlParserUNDO_BUFFER_SIZE, MySqlParserUNINSTALL, MySqlParserUNKNOWN, MySqlParserUNTIL, MySqlParserUPGRADE, MySqlParserUSER, MySqlParserUSE_FRM, MySqlParserUSER_RESOURCES, MySqlParserVALIDATION, MySqlParserVALUE, MySqlParserVARIABLES, MySqlParserVIEW, MySqlParserVIRTUAL, MySqlParserVISIBLE, MySqlParserWAIT, MySqlParserWARNINGS, MySqlParserWITHOUT, MySqlParserWORK, MySqlParserWRAPPER, MySqlParserX509, MySqlParserXA, MySqlParserXML, MySqlParserYES, MySqlParserEUR, MySqlParserUSA, MySqlParserJIS, MySqlParserISO, MySqlParserINTERNAL, MySqlParserQUARTER, MySqlParserMONTH, MySqlParserDAY, MySqlParserHOUR, MySqlParserMINUTE, MySqlParserWEEK, MySqlParserSECOND, MySqlParserMICROSECOND, MySqlParserADMIN, MySqlParserAUDIT_ABORT_EXEMPT, MySqlParserAUDIT_ADMIN, MySqlParserAUTHENTICATION_POLICY_ADMIN, MySqlParserBACKUP_ADMIN, MySqlParserBINLOG_ADMIN, MySqlParserBINLOG_ENCRYPTION_ADMIN, MySqlParserCLONE_ADMIN, MySqlParserCONNECTION_ADMIN, MySqlParserENCRYPTION_KEY_ADMIN, MySqlParserEXECUTE, MySqlParserFILE, MySqlParserFIREWALL_ADMIN, MySqlParserFIREWALL_EXEMPT, MySqlParserFIREWALL_USER, MySqlParserGROUP_REPLICATION_ADMIN, MySqlParserINNODB_REDO_LOG_ARCHIVE, MySqlParserINVOKE, MySqlParserLAMBDA, MySqlParserNDB_STORED_USER, MySqlParserPASSWORDLESS_USER_ADMIN, MySqlParserPERSIST_RO_VARIABLES_ADMIN, MySqlParserPRIVILEGES, MySqlParserPROCESS, MySqlParserRELOAD, MySqlParserREPLICATION_APPLIER, MySqlParserREPLICATION_SLAVE_ADMIN, MySqlParserRESOURCE_GROUP_ADMIN, MySqlParserRESOURCE_GROUP_USER, MySqlParserROLE_ADMIN, MySqlParserROUTINE, MySqlParserS3, MySqlParserSESSION_VARIABLES_ADMIN, MySqlParserSET_USER_ID, MySqlParserSHOW_ROUTINE, MySqlParserSHUTDOWN, MySqlParserSUPER, MySqlParserSYSTEM_VARIABLES_ADMIN, MySqlParserTABLES, MySqlParserTABLE_ENCRYPTION_ADMIN, MySqlParserVERSION_TOKEN_ADMIN, MySqlParserXA_RECOVER_ADMIN, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserARCHIVE, MySqlParserBLACKHOLE, MySqlParserCSV, MySqlParserFEDERATED, MySqlParserINNODB, MySqlParserMEMORY, MySqlParserMRG_MYISAM, MySqlParserMYISAM, MySqlParserNDB, MySqlParserNDBCLUSTER, MySqlParserPERFORMANCE_SCHEMA, MySqlParserTOKUDB, MySqlParserREPEATABLE, MySqlParserCOMMITTED, MySqlParserUNCOMMITTED, MySqlParserSERIALIZABLE, MySqlParserGEOMETRYCOLLECTION, MySqlParserLINESTRING, MySqlParserMULTILINESTRING, MySqlParserMULTIPOINT, MySqlParserMULTIPOLYGON, MySqlParserPOINT, MySqlParserPOLYGON, MySqlParserABS, MySqlParserACOS, MySqlParserADDDATE, MySqlParserADDTIME, MySqlParserAES_DECRYPT, MySqlParserAES_ENCRYPT, MySqlParserAREA, MySqlParserASBINARY, MySqlParserASIN, MySqlParserASTEXT, MySqlParserASWKB, MySqlParserASWKT, MySqlParserASYMMETRIC_DECRYPT, MySqlParserASYMMETRIC_DERIVE, MySqlParserASYMMETRIC_ENCRYPT, MySqlParserASYMMETRIC_SIGN, MySqlParserASYMMETRIC_VERIFY, MySqlParserATAN, MySqlParserATAN2, MySqlParserBENCHMARK, MySqlParserBIN, MySqlParserBIT_COUNT, MySqlParserBIT_LENGTH, MySqlParserBUFFER, MySqlParserCATALOG_NAME, MySqlParserCEIL, MySqlParserCEILING, MySqlParserCENTROID, MySqlParserCHARACTER_LENGTH, MySqlParserCHARSET, MySqlParserCHAR_LENGTH, MySqlParserCOERCIBILITY, MySqlParserCOLLATION, MySqlParserCOMPRESS, MySqlParserCONCAT, MySqlParserCONCAT_WS, MySqlParserCONNECTION_ID, MySqlParserCONV, MySqlParserCONVERT_TZ, MySqlParserCOS, MySqlParserCOT, MySqlParserCRC32, MySqlParserCREATE_ASYMMETRIC_PRIV_KEY, MySqlParserCREATE_ASYMMETRIC_PUB_KEY, MySqlParserCREATE_DH_PARAMETERS, MySqlParserCREATE_DIGEST, MySqlParserCROSSES, MySqlParserDATEDIFF, MySqlParserDATE_FORMAT, MySqlParserDAYNAME, MySqlParserDAYOFMONTH, MySqlParserDAYOFWEEK, MySqlParserDAYOFYEAR, MySqlParserDECODE, MySqlParserDEGREES, MySqlParserDES_DECRYPT, MySqlParserDES_ENCRYPT, MySqlParserDIMENSION, MySqlParserDISJOINT, MySqlParserDISTANCE, MySqlParserELT, MySqlParserENCODE, MySqlParserENCRYPT, MySqlParserENDPOINT, MySqlParserENGINE_ATTRIBUTE, MySqlParserENVELOPE, MySqlParserEQUALS, MySqlParserEXP, MySqlParserEXPORT_SET, MySqlParserEXTERIORRING, MySqlParserEXTRACTVALUE, MySqlParserFIELD, MySqlParserFIND_IN_SET, MySqlParserFLOOR, MySqlParserFORMAT, MySqlParserFOUND_ROWS, MySqlParserFROM_BASE64, MySqlParserFROM_DAYS, MySqlParserFROM_UNIXTIME, MySqlParserGEOMCOLLFROMTEXT, MySqlParserGEOMCOLLFROMWKB, MySqlParserGEOMETRYCOLLECTIONFROMTEXT, MySqlParserGEOMETRYCOLLECTIONFROMWKB, MySqlParserGEOMETRYFROMTEXT, MySqlParserGEOMETRYFROMWKB, MySqlParserGEOMETRYN, MySqlParserGEOMETRYTYPE, MySqlParserGEOMFROMTEXT, MySqlParserGEOMFROMWKB, MySqlParserGET_FORMAT, MySqlParserGET_LOCK, MySqlParserGLENGTH, MySqlParserGREATEST, MySqlParserGTID_SUBSET, MySqlParserGTID_SUBTRACT, MySqlParserHEX, MySqlParserIFNULL, MySqlParserINET6_ATON, MySqlParserINET6_NTOA, MySqlParserINET_ATON, MySqlParserINET_NTOA, MySqlParserINSTR, MySqlParserINTERIORRINGN, MySqlParserINTERSECTS, MySqlParserISCLOSED, MySqlParserISEMPTY, MySqlParserISNULL, MySqlParserISSIMPLE, MySqlParserIS_FREE_LOCK, MySqlParserIS_IPV4, MySqlParserIS_IPV4_COMPAT, MySqlParserIS_IPV4_MAPPED, MySqlParserIS_IPV6, MySqlParserIS_USED_LOCK, MySqlParserLAST_INSERT_ID, MySqlParserLCASE, MySqlParserLEAST, MySqlParserLENGTH, MySqlParserLINEFROMTEXT, MySqlParserLINEFROMWKB, MySqlParserLINESTRINGFROMTEXT, MySqlParserLINESTRINGFROMWKB, MySqlParserLN, MySqlParserLOAD_FILE, MySqlParserLOCATE, MySqlParserLOG, MySqlParserLOG10, MySqlParserLOG2, MySqlParserLOWER, MySqlParserLPAD, MySqlParserLTRIM, MySqlParserMAKEDATE, MySqlParserMAKETIME, MySqlParserMAKE_SET, MySqlParserMASTER_POS_WAIT, MySqlParserMBRCONTAINS, MySqlParserMBRDISJOINT, MySqlParserMBREQUAL, MySqlParserMBRINTERSECTS, MySqlParserMBROVERLAPS, MySqlParserMBRTOUCHES, MySqlParserMBRWITHIN, MySqlParserMD5, MySqlParserMLINEFROMTEXT, MySqlParserMLINEFROMWKB, MySqlParserMONTHNAME, MySqlParserMPOINTFROMTEXT, MySqlParserMPOINTFROMWKB, MySqlParserMPOLYFROMTEXT, MySqlParserMPOLYFROMWKB, MySqlParserMULTILINESTRINGFROMTEXT, MySqlParserMULTILINESTRINGFROMWKB, MySqlParserMULTIPOINTFROMTEXT, MySqlParserMULTIPOINTFROMWKB, MySqlParserMULTIPOLYGONFROMTEXT, MySqlParserMULTIPOLYGONFROMWKB, MySqlParserNAME_CONST, MySqlParserNULLIF, MySqlParserNUMGEOMETRIES, MySqlParserNUMINTERIORRINGS, MySqlParserNUMPOINTS, MySqlParserOCT, MySqlParserOCTET_LENGTH, MySqlParserORD, MySqlParserOVERLAPS, MySqlParserPERIOD_ADD, MySqlParserPERIOD_DIFF, MySqlParserPI, MySqlParserPOINTFROMTEXT, MySqlParserPOINTFROMWKB, MySqlParserPOINTN, MySqlParserPOLYFROMTEXT, MySqlParserPOLYFROMWKB, MySqlParserPOLYGONFROMTEXT, MySqlParserPOLYGONFROMWKB, MySqlParserPOW, MySqlParserPOWER, MySqlParserQUOTE, MySqlParserRADIANS, MySqlParserRAND, MySqlParserRANDOM, MySqlParserRANDOM_BYTES, MySqlParserRELEASE_LOCK, MySqlParserREVERSE, MySqlParserROUND, MySqlParserROW_COUNT, MySqlParserRPAD, MySqlParserRTRIM, MySqlParserSEC_TO_TIME, MySqlParserSECONDARY_ENGINE_ATTRIBUTE, MySqlParserSESSION_USER, MySqlParserSHA, MySqlParserSHA1, MySqlParserSHA2, MySqlParserSCHEMA_NAME, MySqlParserSIGN, MySqlParserSIN, MySqlParserSLEEP, MySqlParserSOUNDEX, MySqlParserSQL_THREAD_WAIT_AFTER_GTIDS, MySqlParserSQRT, MySqlParserSRID, MySqlParserSTARTPOINT, MySqlParserSTRCMP, MySqlParserSTR_TO_DATE, MySqlParserST_AREA, MySqlParserST_ASBINARY, MySqlParserST_ASTEXT, MySqlParserST_ASWKB, MySqlParserST_ASWKT, MySqlParserST_BUFFER, MySqlParserST_CENTROID, MySqlParserST_CONTAINS, MySqlParserST_CROSSES, MySqlParserST_DIFFERENCE, MySqlParserST_DIMENSION, MySqlParserST_DISJOINT, MySqlParserST_DISTANCE, MySqlParserST_ENDPOINT, MySqlParserST_ENVELOPE, MySqlParserST_EQUALS, MySqlParserST_EXTERIORRING, MySqlParserST_GEOMCOLLFROMTEXT, MySqlParserST_GEOMCOLLFROMTXT, MySqlParserST_GEOMCOLLFROMWKB, MySqlParserST_GEOMETRYCOLLECTIONFROMTEXT, MySqlParserST_GEOMETRYCOLLECTIONFROMWKB, MySqlParserST_GEOMETRYFROMTEXT, MySqlParserST_GEOMETRYFROMWKB, MySqlParserST_GEOMETRYN, MySqlParserST_GEOMETRYTYPE, MySqlParserST_GEOMFROMTEXT, MySqlParserST_GEOMFROMWKB, MySqlParserST_INTERIORRINGN, MySqlParserST_INTERSECTION, MySqlParserST_INTERSECTS, MySqlParserST_ISCLOSED, MySqlParserST_ISEMPTY, MySqlParserST_ISSIMPLE, MySqlParserST_LINEFROMTEXT, MySqlParserST_LINEFROMWKB, MySqlParserST_LINESTRINGFROMTEXT, MySqlParserST_LINESTRINGFROMWKB, MySqlParserST_NUMGEOMETRIES, MySqlParserST_NUMINTERIORRING, MySqlParserST_NUMINTERIORRINGS, MySqlParserST_NUMPOINTS, MySqlParserST_OVERLAPS, MySqlParserST_POINTFROMTEXT, MySqlParserST_POINTFROMWKB, MySqlParserST_POINTN, MySqlParserST_POLYFROMTEXT, MySqlParserST_POLYFROMWKB, MySqlParserST_POLYGONFROMTEXT, MySqlParserST_POLYGONFROMWKB, MySqlParserST_SRID, MySqlParserST_STARTPOINT, MySqlParserST_SYMDIFFERENCE, MySqlParserST_TOUCHES, MySqlParserST_UNION, MySqlParserST_WITHIN, MySqlParserST_X, MySqlParserST_Y, MySqlParserSTRING_TO_VECTOR, MySqlParserSUBDATE, MySqlParserSUBSTRING_INDEX, MySqlParserSUBTIME, MySqlParserSYSTEM_USER, MySqlParserTAN, MySqlParserTIMEDIFF, MySqlParserTIMESTAMPADD, MySqlParserTIMESTAMPDIFF, MySqlParserTIME_FORMAT, MySqlParserTIME_TO_SEC, MySqlParserTOUCHES, MySqlParserTO_BASE64, MySqlParserTO_DAYS, MySqlParserTO_SECONDS, MySqlParserTP_CONNECTION_ADMIN, MySqlParserUCASE, MySqlParserUNCOMPRESS, MySqlParserUNCOMPRESSED_LENGTH, MySqlParserUNHEX, MySqlParserUNIX_TIMESTAMP, MySqlParserUPDATEXML, MySqlParserUPPER, MySqlParserUUID, MySqlParserUUID_SHORT, MySqlParserVALIDATE_PASSWORD_STRENGTH, MySqlParserVECTOR_DIM, MySqlParserVECTOR_TO_STRING, MySqlParserVERSION, MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS, MySqlParserWEEKDAY, MySqlParserWEEKOFYEAR, MySqlParserWEIGHT_STRING, MySqlParserWITHIN, MySqlParserYEARWEEK, MySqlParserY_FUNCTION, MySqlParserX_FUNCTION, MySqlParserMOD, MySqlParserCHARSET_REVERSE_QOUTE_STRING, MySqlParserSTRING_LITERAL, MySqlParserID: + { + p.SetState(6033) + p.UidList() + } + + case MySqlParserALL: + { + p.SetState(6034) + p.Match(MySqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(6037) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6040) + p.Match(MySqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6041) + + var _x = p.Uid() + + localctx.(*CacheIndexStatementContext).schema = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFlushStatementContext is an interface to support dynamic dispatch. +type IFlushStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetFlushFormat returns the flushFormat token. + GetFlushFormat() antlr.Token + + // SetFlushFormat sets the flushFormat token. + SetFlushFormat(antlr.Token) + + // Getter signatures + FLUSH() antlr.TerminalNode + AllFlushOption() []IFlushOptionContext + FlushOption(i int) IFlushOptionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + NO_WRITE_TO_BINLOG() antlr.TerminalNode + LOCAL() antlr.TerminalNode + + // IsFlushStatementContext differentiates from other interfaces. + IsFlushStatementContext() +} + +type FlushStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + flushFormat antlr.Token +} + +func NewEmptyFlushStatementContext() *FlushStatementContext { + var p = new(FlushStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_flushStatement + return p +} + +func InitEmptyFlushStatementContext(p *FlushStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_flushStatement +} + +func (*FlushStatementContext) IsFlushStatementContext() {} + +func NewFlushStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FlushStatementContext { + var p = new(FlushStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_flushStatement + + return p +} + +func (s *FlushStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *FlushStatementContext) GetFlushFormat() antlr.Token { return s.flushFormat } + +func (s *FlushStatementContext) SetFlushFormat(v antlr.Token) { s.flushFormat = v } + +func (s *FlushStatementContext) FLUSH() antlr.TerminalNode { + return s.GetToken(MySqlParserFLUSH, 0) +} + +func (s *FlushStatementContext) AllFlushOption() []IFlushOptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFlushOptionContext); ok { + len++ + } + } + + tst := make([]IFlushOptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFlushOptionContext); ok { + tst[i] = t.(IFlushOptionContext) + i++ + } + } + + return tst +} + +func (s *FlushStatementContext) FlushOption(i int) IFlushOptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFlushOptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFlushOptionContext) +} + +func (s *FlushStatementContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *FlushStatementContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *FlushStatementContext) NO_WRITE_TO_BINLOG() antlr.TerminalNode { + return s.GetToken(MySqlParserNO_WRITE_TO_BINLOG, 0) +} + +func (s *FlushStatementContext) LOCAL() antlr.TerminalNode { + return s.GetToken(MySqlParserLOCAL, 0) +} + +func (s *FlushStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FlushStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FlushStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterFlushStatement(s) + } +} + +func (s *FlushStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitFlushStatement(s) + } +} + +func (p *MySqlParser) FlushStatement() (localctx IFlushStatementContext) { + localctx = NewFlushStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 508, MySqlParserRULE_flushStatement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6043) + p.Match(MySqlParserFLUSH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6045) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserNO_WRITE_TO_BINLOG || _la == MySqlParserLOCAL { + { + p.SetState(6044) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*FlushStatementContext).flushFormat = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserNO_WRITE_TO_BINLOG || _la == MySqlParserLOCAL) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*FlushStatementContext).flushFormat = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(6047) + p.FlushOption() + } + p.SetState(6052) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(6048) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6049) + p.FlushOption() + } + + p.SetState(6054) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKillStatementContext is an interface to support dynamic dispatch. +type IKillStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetConnectionFormat returns the connectionFormat token. + GetConnectionFormat() antlr.Token + + // SetConnectionFormat sets the connectionFormat token. + SetConnectionFormat(antlr.Token) + + // Getter signatures + KILL() antlr.TerminalNode + Expression() IExpressionContext + CONNECTION() antlr.TerminalNode + QUERY() antlr.TerminalNode + + // IsKillStatementContext differentiates from other interfaces. + IsKillStatementContext() +} + +type KillStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + connectionFormat antlr.Token +} + +func NewEmptyKillStatementContext() *KillStatementContext { + var p = new(KillStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_killStatement + return p +} + +func InitEmptyKillStatementContext(p *KillStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_killStatement +} + +func (*KillStatementContext) IsKillStatementContext() {} + +func NewKillStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KillStatementContext { + var p = new(KillStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_killStatement + + return p +} + +func (s *KillStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *KillStatementContext) GetConnectionFormat() antlr.Token { return s.connectionFormat } + +func (s *KillStatementContext) SetConnectionFormat(v antlr.Token) { s.connectionFormat = v } + +func (s *KillStatementContext) KILL() antlr.TerminalNode { + return s.GetToken(MySqlParserKILL, 0) +} + +func (s *KillStatementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *KillStatementContext) CONNECTION() antlr.TerminalNode { + return s.GetToken(MySqlParserCONNECTION, 0) +} + +func (s *KillStatementContext) QUERY() antlr.TerminalNode { + return s.GetToken(MySqlParserQUERY, 0) +} + +func (s *KillStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KillStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KillStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterKillStatement(s) + } +} + +func (s *KillStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitKillStatement(s) + } +} + +func (p *MySqlParser) KillStatement() (localctx IKillStatementContext) { + localctx = NewKillStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 510, MySqlParserRULE_killStatement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6055) + p.Match(MySqlParserKILL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6057) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 885, p.GetParserRuleContext()) == 1 { + { + p.SetState(6056) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*KillStatementContext).connectionFormat = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserCONNECTION || _la == MySqlParserQUERY) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*KillStatementContext).connectionFormat = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6059) + p.expression(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILoadIndexIntoCacheContext is an interface to support dynamic dispatch. +type ILoadIndexIntoCacheContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LOAD() antlr.TerminalNode + INDEX() antlr.TerminalNode + INTO() antlr.TerminalNode + CACHE() antlr.TerminalNode + AllLoadedTableIndexes() []ILoadedTableIndexesContext + LoadedTableIndexes(i int) ILoadedTableIndexesContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsLoadIndexIntoCacheContext differentiates from other interfaces. + IsLoadIndexIntoCacheContext() +} + +type LoadIndexIntoCacheContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLoadIndexIntoCacheContext() *LoadIndexIntoCacheContext { + var p = new(LoadIndexIntoCacheContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_loadIndexIntoCache + return p +} + +func InitEmptyLoadIndexIntoCacheContext(p *LoadIndexIntoCacheContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_loadIndexIntoCache +} + +func (*LoadIndexIntoCacheContext) IsLoadIndexIntoCacheContext() {} + +func NewLoadIndexIntoCacheContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LoadIndexIntoCacheContext { + var p = new(LoadIndexIntoCacheContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_loadIndexIntoCache + + return p +} + +func (s *LoadIndexIntoCacheContext) GetParser() antlr.Parser { return s.parser } + +func (s *LoadIndexIntoCacheContext) LOAD() antlr.TerminalNode { + return s.GetToken(MySqlParserLOAD, 0) +} + +func (s *LoadIndexIntoCacheContext) INDEX() antlr.TerminalNode { + return s.GetToken(MySqlParserINDEX, 0) +} + +func (s *LoadIndexIntoCacheContext) INTO() antlr.TerminalNode { + return s.GetToken(MySqlParserINTO, 0) +} + +func (s *LoadIndexIntoCacheContext) CACHE() antlr.TerminalNode { + return s.GetToken(MySqlParserCACHE, 0) +} + +func (s *LoadIndexIntoCacheContext) AllLoadedTableIndexes() []ILoadedTableIndexesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILoadedTableIndexesContext); ok { + len++ + } + } + + tst := make([]ILoadedTableIndexesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILoadedTableIndexesContext); ok { + tst[i] = t.(ILoadedTableIndexesContext) + i++ + } + } + + return tst +} + +func (s *LoadIndexIntoCacheContext) LoadedTableIndexes(i int) ILoadedTableIndexesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILoadedTableIndexesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILoadedTableIndexesContext) +} + +func (s *LoadIndexIntoCacheContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *LoadIndexIntoCacheContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *LoadIndexIntoCacheContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LoadIndexIntoCacheContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *LoadIndexIntoCacheContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterLoadIndexIntoCache(s) + } +} + +func (s *LoadIndexIntoCacheContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitLoadIndexIntoCache(s) + } +} + +func (p *MySqlParser) LoadIndexIntoCache() (localctx ILoadIndexIntoCacheContext) { + localctx = NewLoadIndexIntoCacheContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 512, MySqlParserRULE_loadIndexIntoCache) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6061) + p.Match(MySqlParserLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6062) + p.Match(MySqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6063) + p.Match(MySqlParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6064) + p.Match(MySqlParserCACHE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6065) + p.LoadedTableIndexes() + } + p.SetState(6070) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(6066) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6067) + p.LoadedTableIndexes() + } + + p.SetState(6072) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IResetStatementContext is an interface to support dynamic dispatch. +type IResetStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RESET() antlr.TerminalNode + QUERY() antlr.TerminalNode + CACHE() antlr.TerminalNode + + // IsResetStatementContext differentiates from other interfaces. + IsResetStatementContext() +} + +type ResetStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyResetStatementContext() *ResetStatementContext { + var p = new(ResetStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_resetStatement + return p +} + +func InitEmptyResetStatementContext(p *ResetStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_resetStatement +} + +func (*ResetStatementContext) IsResetStatementContext() {} + +func NewResetStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ResetStatementContext { + var p = new(ResetStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_resetStatement + + return p +} + +func (s *ResetStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *ResetStatementContext) RESET() antlr.TerminalNode { + return s.GetToken(MySqlParserRESET, 0) +} + +func (s *ResetStatementContext) QUERY() antlr.TerminalNode { + return s.GetToken(MySqlParserQUERY, 0) +} + +func (s *ResetStatementContext) CACHE() antlr.TerminalNode { + return s.GetToken(MySqlParserCACHE, 0) +} + +func (s *ResetStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ResetStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ResetStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterResetStatement(s) + } +} + +func (s *ResetStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitResetStatement(s) + } +} + +func (p *MySqlParser) ResetStatement() (localctx IResetStatementContext) { + localctx = NewResetStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 514, MySqlParserRULE_resetStatement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6073) + p.Match(MySqlParserRESET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6074) + p.Match(MySqlParserQUERY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6075) + p.Match(MySqlParserCACHE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShutdownStatementContext is an interface to support dynamic dispatch. +type IShutdownStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHUTDOWN() antlr.TerminalNode + + // IsShutdownStatementContext differentiates from other interfaces. + IsShutdownStatementContext() +} + +type ShutdownStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShutdownStatementContext() *ShutdownStatementContext { + var p = new(ShutdownStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_shutdownStatement + return p +} + +func InitEmptyShutdownStatementContext(p *ShutdownStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_shutdownStatement +} + +func (*ShutdownStatementContext) IsShutdownStatementContext() {} + +func NewShutdownStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ShutdownStatementContext { + var p = new(ShutdownStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_shutdownStatement + + return p +} + +func (s *ShutdownStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *ShutdownStatementContext) SHUTDOWN() antlr.TerminalNode { + return s.GetToken(MySqlParserSHUTDOWN, 0) +} + +func (s *ShutdownStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShutdownStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ShutdownStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterShutdownStatement(s) + } +} + +func (s *ShutdownStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitShutdownStatement(s) + } +} + +func (p *MySqlParser) ShutdownStatement() (localctx IShutdownStatementContext) { + localctx = NewShutdownStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 516, MySqlParserRULE_shutdownStatement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6077) + p.Match(MySqlParserSHUTDOWN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITableIndexesContext is an interface to support dynamic dispatch. +type ITableIndexesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetIndexFormat returns the indexFormat token. + GetIndexFormat() antlr.Token + + // SetIndexFormat sets the indexFormat token. + SetIndexFormat(antlr.Token) + + // Getter signatures + TableName() ITableNameContext + LR_BRACKET() antlr.TerminalNode + UidList() IUidListContext + RR_BRACKET() antlr.TerminalNode + INDEX() antlr.TerminalNode + KEY() antlr.TerminalNode + + // IsTableIndexesContext differentiates from other interfaces. + IsTableIndexesContext() +} + +type TableIndexesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + indexFormat antlr.Token +} + +func NewEmptyTableIndexesContext() *TableIndexesContext { + var p = new(TableIndexesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_tableIndexes + return p +} + +func InitEmptyTableIndexesContext(p *TableIndexesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_tableIndexes +} + +func (*TableIndexesContext) IsTableIndexesContext() {} + +func NewTableIndexesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableIndexesContext { + var p = new(TableIndexesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_tableIndexes + + return p +} + +func (s *TableIndexesContext) GetParser() antlr.Parser { return s.parser } + +func (s *TableIndexesContext) GetIndexFormat() antlr.Token { return s.indexFormat } + +func (s *TableIndexesContext) SetIndexFormat(v antlr.Token) { s.indexFormat = v } + +func (s *TableIndexesContext) TableName() ITableNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableNameContext) +} + +func (s *TableIndexesContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *TableIndexesContext) UidList() IUidListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidListContext) +} + +func (s *TableIndexesContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *TableIndexesContext) INDEX() antlr.TerminalNode { + return s.GetToken(MySqlParserINDEX, 0) +} + +func (s *TableIndexesContext) KEY() antlr.TerminalNode { + return s.GetToken(MySqlParserKEY, 0) +} + +func (s *TableIndexesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableIndexesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TableIndexesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTableIndexes(s) + } +} + +func (s *TableIndexesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTableIndexes(s) + } +} + +func (p *MySqlParser) TableIndexes() (localctx ITableIndexesContext) { + localctx = NewTableIndexesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 518, MySqlParserRULE_tableIndexes) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6079) + p.TableName() + } + p.SetState(6087) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserINDEX || _la == MySqlParserKEY || _la == MySqlParserLR_BRACKET { + p.SetState(6081) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserINDEX || _la == MySqlParserKEY { + { + p.SetState(6080) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*TableIndexesContext).indexFormat = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserINDEX || _la == MySqlParserKEY) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*TableIndexesContext).indexFormat = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(6083) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6084) + p.UidList() + } + { + p.SetState(6085) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFlushOptionContext is an interface to support dynamic dispatch. +type IFlushOptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsFlushOptionContext differentiates from other interfaces. + IsFlushOptionContext() +} + +type FlushOptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFlushOptionContext() *FlushOptionContext { + var p = new(FlushOptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_flushOption + return p +} + +func InitEmptyFlushOptionContext(p *FlushOptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_flushOption +} + +func (*FlushOptionContext) IsFlushOptionContext() {} + +func NewFlushOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FlushOptionContext { + var p = new(FlushOptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_flushOption + + return p +} + +func (s *FlushOptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *FlushOptionContext) CopyAll(ctx *FlushOptionContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *FlushOptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FlushOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type TableFlushOptionContext struct { + FlushOptionContext +} + +func NewTableFlushOptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableFlushOptionContext { + var p = new(TableFlushOptionContext) + + InitEmptyFlushOptionContext(&p.FlushOptionContext) + p.parser = parser + p.CopyAll(ctx.(*FlushOptionContext)) + + return p +} + +func (s *TableFlushOptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableFlushOptionContext) TABLE() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLE, 0) +} + +func (s *TableFlushOptionContext) TABLES() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLES, 0) +} + +func (s *TableFlushOptionContext) Tables() ITablesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablesContext) +} + +func (s *TableFlushOptionContext) FlushTableOption() IFlushTableOptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFlushTableOptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFlushTableOptionContext) +} + +func (s *TableFlushOptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTableFlushOption(s) + } +} + +func (s *TableFlushOptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTableFlushOption(s) + } +} + +type ChannelFlushOptionContext struct { + FlushOptionContext +} + +func NewChannelFlushOptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ChannelFlushOptionContext { + var p = new(ChannelFlushOptionContext) + + InitEmptyFlushOptionContext(&p.FlushOptionContext) + p.parser = parser + p.CopyAll(ctx.(*FlushOptionContext)) + + return p +} + +func (s *ChannelFlushOptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ChannelFlushOptionContext) RELAY() antlr.TerminalNode { + return s.GetToken(MySqlParserRELAY, 0) +} + +func (s *ChannelFlushOptionContext) LOGS() antlr.TerminalNode { + return s.GetToken(MySqlParserLOGS, 0) +} + +func (s *ChannelFlushOptionContext) ChannelOption() IChannelOptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IChannelOptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IChannelOptionContext) +} + +func (s *ChannelFlushOptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterChannelFlushOption(s) + } +} + +func (s *ChannelFlushOptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitChannelFlushOption(s) + } +} + +type SimpleFlushOptionContext struct { + FlushOptionContext +} + +func NewSimpleFlushOptionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SimpleFlushOptionContext { + var p = new(SimpleFlushOptionContext) + + InitEmptyFlushOptionContext(&p.FlushOptionContext) + p.parser = parser + p.CopyAll(ctx.(*FlushOptionContext)) + + return p +} + +func (s *SimpleFlushOptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SimpleFlushOptionContext) DES_KEY_FILE() antlr.TerminalNode { + return s.GetToken(MySqlParserDES_KEY_FILE, 0) +} + +func (s *SimpleFlushOptionContext) HOSTS() antlr.TerminalNode { + return s.GetToken(MySqlParserHOSTS, 0) +} + +func (s *SimpleFlushOptionContext) LOGS() antlr.TerminalNode { + return s.GetToken(MySqlParserLOGS, 0) +} + +func (s *SimpleFlushOptionContext) OPTIMIZER_COSTS() antlr.TerminalNode { + return s.GetToken(MySqlParserOPTIMIZER_COSTS, 0) +} + +func (s *SimpleFlushOptionContext) PRIVILEGES() antlr.TerminalNode { + return s.GetToken(MySqlParserPRIVILEGES, 0) +} + +func (s *SimpleFlushOptionContext) QUERY() antlr.TerminalNode { + return s.GetToken(MySqlParserQUERY, 0) +} + +func (s *SimpleFlushOptionContext) CACHE() antlr.TerminalNode { + return s.GetToken(MySqlParserCACHE, 0) +} + +func (s *SimpleFlushOptionContext) STATUS() antlr.TerminalNode { + return s.GetToken(MySqlParserSTATUS, 0) +} + +func (s *SimpleFlushOptionContext) USER_RESOURCES() antlr.TerminalNode { + return s.GetToken(MySqlParserUSER_RESOURCES, 0) +} + +func (s *SimpleFlushOptionContext) TABLES() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLES, 0) +} + +func (s *SimpleFlushOptionContext) WITH() antlr.TerminalNode { + return s.GetToken(MySqlParserWITH, 0) +} + +func (s *SimpleFlushOptionContext) READ() antlr.TerminalNode { + return s.GetToken(MySqlParserREAD, 0) +} + +func (s *SimpleFlushOptionContext) LOCK() antlr.TerminalNode { + return s.GetToken(MySqlParserLOCK, 0) +} + +func (s *SimpleFlushOptionContext) BINARY() antlr.TerminalNode { + return s.GetToken(MySqlParserBINARY, 0) +} + +func (s *SimpleFlushOptionContext) ENGINE() antlr.TerminalNode { + return s.GetToken(MySqlParserENGINE, 0) +} + +func (s *SimpleFlushOptionContext) ERROR() antlr.TerminalNode { + return s.GetToken(MySqlParserERROR, 0) +} + +func (s *SimpleFlushOptionContext) GENERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserGENERAL, 0) +} + +func (s *SimpleFlushOptionContext) RELAY() antlr.TerminalNode { + return s.GetToken(MySqlParserRELAY, 0) +} + +func (s *SimpleFlushOptionContext) SLOW() antlr.TerminalNode { + return s.GetToken(MySqlParserSLOW, 0) +} + +func (s *SimpleFlushOptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSimpleFlushOption(s) + } +} + +func (s *SimpleFlushOptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSimpleFlushOption(s) + } +} + +func (p *MySqlParser) FlushOption() (localctx IFlushOptionContext) { + localctx = NewFlushOptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 520, MySqlParserRULE_flushOption) + var _la int + + p.SetState(6121) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 895, p.GetParserRuleContext()) { + case 1: + localctx = NewSimpleFlushOptionContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + p.SetState(6107) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserDES_KEY_FILE: + { + p.SetState(6089) + p.Match(MySqlParserDES_KEY_FILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserHOSTS: + { + p.SetState(6090) + p.Match(MySqlParserHOSTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserBINARY, MySqlParserENGINE, MySqlParserERROR, MySqlParserGENERAL, MySqlParserLOGS, MySqlParserRELAY, MySqlParserSLOW: + p.SetState(6092) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserBINARY || ((int64((_la-410)) & ^0x3f) == 0 && ((int64(1)<<(_la-410))&536870917) != 0) || _la == MySqlParserRELAY || _la == MySqlParserSLOW { + { + p.SetState(6091) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserBINARY || ((int64((_la-410)) & ^0x3f) == 0 && ((int64(1)<<(_la-410))&536870917) != 0) || _la == MySqlParserRELAY || _la == MySqlParserSLOW) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(6094) + p.Match(MySqlParserLOGS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserOPTIMIZER_COSTS: + { + p.SetState(6095) + p.Match(MySqlParserOPTIMIZER_COSTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserPRIVILEGES: + { + p.SetState(6096) + p.Match(MySqlParserPRIVILEGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserQUERY: + { + p.SetState(6097) + p.Match(MySqlParserQUERY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6098) + p.Match(MySqlParserCACHE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserSTATUS: + { + p.SetState(6099) + p.Match(MySqlParserSTATUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserUSER_RESOURCES: + { + p.SetState(6100) + p.Match(MySqlParserUSER_RESOURCES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserTABLES: + { + p.SetState(6101) + p.Match(MySqlParserTABLES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6105) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 890, p.GetParserRuleContext()) == 1 { + { + p.SetState(6102) + p.Match(MySqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6103) + p.Match(MySqlParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6104) + p.Match(MySqlParserLOCK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 2: + localctx = NewChannelFlushOptionContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6109) + p.Match(MySqlParserRELAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6110) + p.Match(MySqlParserLOGS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6112) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserFOR { + { + p.SetState(6111) + p.ChannelOption() + } + + } + + case 3: + localctx = NewTableFlushOptionContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6114) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserTABLE || _la == MySqlParserTABLES) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(6116) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 893, p.GetParserRuleContext()) == 1 { + { + p.SetState(6115) + p.Tables() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6119) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 894, p.GetParserRuleContext()) == 1 { + { + p.SetState(6118) + p.FlushTableOption() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFlushTableOptionContext is an interface to support dynamic dispatch. +type IFlushTableOptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH() antlr.TerminalNode + READ() antlr.TerminalNode + LOCK() antlr.TerminalNode + FOR() antlr.TerminalNode + EXPORT() antlr.TerminalNode + + // IsFlushTableOptionContext differentiates from other interfaces. + IsFlushTableOptionContext() +} + +type FlushTableOptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFlushTableOptionContext() *FlushTableOptionContext { + var p = new(FlushTableOptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_flushTableOption + return p +} + +func InitEmptyFlushTableOptionContext(p *FlushTableOptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_flushTableOption +} + +func (*FlushTableOptionContext) IsFlushTableOptionContext() {} + +func NewFlushTableOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FlushTableOptionContext { + var p = new(FlushTableOptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_flushTableOption + + return p +} + +func (s *FlushTableOptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *FlushTableOptionContext) WITH() antlr.TerminalNode { + return s.GetToken(MySqlParserWITH, 0) +} + +func (s *FlushTableOptionContext) READ() antlr.TerminalNode { + return s.GetToken(MySqlParserREAD, 0) +} + +func (s *FlushTableOptionContext) LOCK() antlr.TerminalNode { + return s.GetToken(MySqlParserLOCK, 0) +} + +func (s *FlushTableOptionContext) FOR() antlr.TerminalNode { + return s.GetToken(MySqlParserFOR, 0) +} + +func (s *FlushTableOptionContext) EXPORT() antlr.TerminalNode { + return s.GetToken(MySqlParserEXPORT, 0) +} + +func (s *FlushTableOptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FlushTableOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FlushTableOptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterFlushTableOption(s) + } +} + +func (s *FlushTableOptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitFlushTableOption(s) + } +} + +func (p *MySqlParser) FlushTableOption() (localctx IFlushTableOptionContext) { + localctx = NewFlushTableOptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 522, MySqlParserRULE_flushTableOption) + p.SetState(6128) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserWITH: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6123) + p.Match(MySqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6124) + p.Match(MySqlParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6125) + p.Match(MySqlParserLOCK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserFOR: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6126) + p.Match(MySqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6127) + p.Match(MySqlParserEXPORT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILoadedTableIndexesContext is an interface to support dynamic dispatch. +type ILoadedTableIndexesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetIndexFormat returns the indexFormat token. + GetIndexFormat() antlr.Token + + // SetIndexFormat sets the indexFormat token. + SetIndexFormat(antlr.Token) + + // GetPartitionList returns the partitionList rule contexts. + GetPartitionList() IUidListContext + + // GetIndexList returns the indexList rule contexts. + GetIndexList() IUidListContext + + // SetPartitionList sets the partitionList rule contexts. + SetPartitionList(IUidListContext) + + // SetIndexList sets the indexList rule contexts. + SetIndexList(IUidListContext) + + // Getter signatures + TableName() ITableNameContext + PARTITION() antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + IGNORE() antlr.TerminalNode + LEAVES() antlr.TerminalNode + AllUidList() []IUidListContext + UidList(i int) IUidListContext + ALL() antlr.TerminalNode + INDEX() antlr.TerminalNode + KEY() antlr.TerminalNode + + // IsLoadedTableIndexesContext differentiates from other interfaces. + IsLoadedTableIndexesContext() +} + +type LoadedTableIndexesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + partitionList IUidListContext + indexFormat antlr.Token + indexList IUidListContext +} + +func NewEmptyLoadedTableIndexesContext() *LoadedTableIndexesContext { + var p = new(LoadedTableIndexesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_loadedTableIndexes + return p +} + +func InitEmptyLoadedTableIndexesContext(p *LoadedTableIndexesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_loadedTableIndexes +} + +func (*LoadedTableIndexesContext) IsLoadedTableIndexesContext() {} + +func NewLoadedTableIndexesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LoadedTableIndexesContext { + var p = new(LoadedTableIndexesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_loadedTableIndexes + + return p +} + +func (s *LoadedTableIndexesContext) GetParser() antlr.Parser { return s.parser } + +func (s *LoadedTableIndexesContext) GetIndexFormat() antlr.Token { return s.indexFormat } + +func (s *LoadedTableIndexesContext) SetIndexFormat(v antlr.Token) { s.indexFormat = v } + +func (s *LoadedTableIndexesContext) GetPartitionList() IUidListContext { return s.partitionList } + +func (s *LoadedTableIndexesContext) GetIndexList() IUidListContext { return s.indexList } + +func (s *LoadedTableIndexesContext) SetPartitionList(v IUidListContext) { s.partitionList = v } + +func (s *LoadedTableIndexesContext) SetIndexList(v IUidListContext) { s.indexList = v } + +func (s *LoadedTableIndexesContext) TableName() ITableNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableNameContext) +} + +func (s *LoadedTableIndexesContext) PARTITION() antlr.TerminalNode { + return s.GetToken(MySqlParserPARTITION, 0) +} + +func (s *LoadedTableIndexesContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(MySqlParserLR_BRACKET) +} + +func (s *LoadedTableIndexesContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, i) +} + +func (s *LoadedTableIndexesContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(MySqlParserRR_BRACKET) +} + +func (s *LoadedTableIndexesContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, i) +} + +func (s *LoadedTableIndexesContext) IGNORE() antlr.TerminalNode { + return s.GetToken(MySqlParserIGNORE, 0) +} + +func (s *LoadedTableIndexesContext) LEAVES() antlr.TerminalNode { + return s.GetToken(MySqlParserLEAVES, 0) +} + +func (s *LoadedTableIndexesContext) AllUidList() []IUidListContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUidListContext); ok { + len++ + } + } + + tst := make([]IUidListContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUidListContext); ok { + tst[i] = t.(IUidListContext) + i++ + } + } + + return tst +} + +func (s *LoadedTableIndexesContext) UidList(i int) IUidListContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidListContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUidListContext) +} + +func (s *LoadedTableIndexesContext) ALL() antlr.TerminalNode { + return s.GetToken(MySqlParserALL, 0) +} + +func (s *LoadedTableIndexesContext) INDEX() antlr.TerminalNode { + return s.GetToken(MySqlParserINDEX, 0) +} + +func (s *LoadedTableIndexesContext) KEY() antlr.TerminalNode { + return s.GetToken(MySqlParserKEY, 0) +} + +func (s *LoadedTableIndexesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LoadedTableIndexesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *LoadedTableIndexesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterLoadedTableIndexes(s) + } +} + +func (s *LoadedTableIndexesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitLoadedTableIndexes(s) + } +} + +func (p *MySqlParser) LoadedTableIndexes() (localctx ILoadedTableIndexesContext) { + localctx = NewLoadedTableIndexesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 524, MySqlParserRULE_loadedTableIndexes) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6130) + p.TableName() + } + p.SetState(6138) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserPARTITION { + { + p.SetState(6131) + p.Match(MySqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6132) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6135) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserARRAY, MySqlParserATTRIBUTE, MySqlParserBUCKETS, MySqlParserCONDITION, MySqlParserCURRENT, MySqlParserCURRENT_USER, MySqlParserDATABASE, MySqlParserDEFAULT, MySqlParserDIAGNOSTICS, MySqlParserEMPTY, MySqlParserENFORCED, MySqlParserEXCEPT, MySqlParserGROUP, MySqlParserIF, MySqlParserIGNORED, MySqlParserINSERT, MySqlParserLATERAL, MySqlParserLEFT, MySqlParserNUMBER, MySqlParserOPTIONAL, MySqlParserORDER, MySqlParserPRIMARY, MySqlParserREPEAT, MySqlParserREPLACE, MySqlParserRIGHT, MySqlParserSCHEMA, MySqlParserSKIP_QUERY_REWRITE, MySqlParserSTACKED, MySqlParserSTATEMENT, MySqlParserDATE, MySqlParserTIME, MySqlParserTIMESTAMP, MySqlParserDATETIME, MySqlParserYEAR, MySqlParserBINARY, MySqlParserTEXT, MySqlParserENUM, MySqlParserSERIAL, MySqlParserJSON_ARRAY, MySqlParserJSON_ARRAYAGG, MySqlParserJSON_ARRAY_APPEND, MySqlParserJSON_ARRAY_INSERT, MySqlParserJSON_CONTAINS, MySqlParserJSON_CONTAINS_PATH, MySqlParserJSON_DEPTH, MySqlParserJSON_EXTRACT, MySqlParserJSON_INSERT, MySqlParserJSON_KEYS, MySqlParserJSON_LENGTH, MySqlParserJSON_MERGE, MySqlParserJSON_MERGE_PATCH, MySqlParserJSON_MERGE_PRESERVE, MySqlParserJSON_OBJECT, MySqlParserJSON_OBJECTAGG, MySqlParserJSON_OVERLAPS, MySqlParserJSON_PRETTY, MySqlParserJSON_QUOTE, MySqlParserJSON_REMOVE, MySqlParserJSON_REPLACE, MySqlParserJSON_SCHEMA_VALID, MySqlParserJSON_SCHEMA_VALIDATION_REPORT, MySqlParserJSON_SEARCH, MySqlParserJSON_SET, MySqlParserJSON_STORAGE_FREE, MySqlParserJSON_STORAGE_SIZE, MySqlParserJSON_TABLE, MySqlParserJSON_TYPE, MySqlParserJSON_UNQUOTE, MySqlParserJSON_VALID, MySqlParserJSON_VALUE, MySqlParserNESTED, MySqlParserORDINALITY, MySqlParserPATH, MySqlParserAVG, MySqlParserBIT_AND, MySqlParserBIT_OR, MySqlParserBIT_XOR, MySqlParserCOUNT, MySqlParserCUME_DIST, MySqlParserDENSE_RANK, MySqlParserFIRST_VALUE, MySqlParserGROUP_CONCAT, MySqlParserLAG, MySqlParserLAST_VALUE, MySqlParserLEAD, MySqlParserMAX, MySqlParserMIN, MySqlParserNTILE, MySqlParserNTH_VALUE, MySqlParserPERCENT_RANK, MySqlParserRANK, MySqlParserROW_NUMBER, MySqlParserSTD, MySqlParserSTDDEV, MySqlParserSTDDEV_POP, MySqlParserSTDDEV_SAMP, MySqlParserSUM, MySqlParserVAR_POP, MySqlParserVAR_SAMP, MySqlParserVARIANCE, MySqlParserCURRENT_DATE, MySqlParserCURRENT_TIME, MySqlParserCURRENT_TIMESTAMP, MySqlParserLOCALTIME, MySqlParserCURDATE, MySqlParserCURTIME, MySqlParserDATE_ADD, MySqlParserDATE_SUB, MySqlParserLOCALTIMESTAMP, MySqlParserNOW, MySqlParserPOSITION, MySqlParserSUBSTR, MySqlParserSUBSTRING, MySqlParserSYSDATE, MySqlParserTRIM, MySqlParserUTC_DATE, MySqlParserUTC_TIME, MySqlParserUTC_TIMESTAMP, MySqlParserACCOUNT, MySqlParserACTION, MySqlParserAFTER, MySqlParserAGGREGATE, MySqlParserALGORITHM, MySqlParserANY, MySqlParserAT, MySqlParserAUTHORS, MySqlParserAUTOCOMMIT, MySqlParserAUTOEXTEND_SIZE, MySqlParserAUTO_INCREMENT, MySqlParserAVG_ROW_LENGTH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserBIT, MySqlParserBLOCK, MySqlParserBOOL, MySqlParserBOOLEAN, MySqlParserBTREE, MySqlParserCACHE, MySqlParserCASCADED, MySqlParserCHAIN, MySqlParserCHANGED, MySqlParserCHANNEL, MySqlParserCHECKSUM, MySqlParserPAGE_CHECKSUM, MySqlParserCIPHER, MySqlParserCLASS_ORIGIN, MySqlParserCLIENT, MySqlParserCLOSE, MySqlParserCLUSTERING, MySqlParserCOALESCE, MySqlParserCODE, MySqlParserCOLUMNS, MySqlParserCOLUMN_FORMAT, MySqlParserCOLUMN_NAME, MySqlParserCOMMENT, MySqlParserCOMMIT, MySqlParserCOMPACT, MySqlParserCOMPLETION, MySqlParserCOMPRESSED, MySqlParserCOMPRESSION, MySqlParserCONCURRENT, MySqlParserCONNECT, MySqlParserCONNECTION, MySqlParserCONSISTENT, MySqlParserCONSTRAINT_CATALOG, MySqlParserCONSTRAINT_SCHEMA, MySqlParserCONSTRAINT_NAME, MySqlParserCONTAINS, MySqlParserCONTEXT, MySqlParserCONTRIBUTORS, MySqlParserCOPY, MySqlParserCPU, MySqlParserCURSOR_NAME, MySqlParserDATA, MySqlParserDATAFILE, MySqlParserDEALLOCATE, MySqlParserDEFAULT_AUTH, MySqlParserDEFINER, MySqlParserDELAY_KEY_WRITE, MySqlParserDES_KEY_FILE, MySqlParserDIRECTORY, MySqlParserDISABLE, MySqlParserDISCARD, MySqlParserDISK, MySqlParserDO, MySqlParserDUMPFILE, MySqlParserDUPLICATE, MySqlParserDYNAMIC, MySqlParserENABLE, MySqlParserENCRYPTION, MySqlParserEND, MySqlParserENDS, MySqlParserENGINE, MySqlParserENGINES, MySqlParserERROR, MySqlParserERRORS, MySqlParserESCAPE, MySqlParserEVEN, MySqlParserEVENT, MySqlParserEVENTS, MySqlParserEVERY, MySqlParserEXCHANGE, MySqlParserEXCLUSIVE, MySqlParserEXPIRE, MySqlParserEXPORT, MySqlParserEXTENDED, MySqlParserEXTENT_SIZE, MySqlParserFAILED_LOGIN_ATTEMPTS, MySqlParserFAST, MySqlParserFAULTS, MySqlParserFIELDS, MySqlParserFILE_BLOCK_SIZE, MySqlParserFILTER, MySqlParserFIRST, MySqlParserFIXED, MySqlParserFLUSH, MySqlParserFOLLOWS, MySqlParserFOUND, MySqlParserFULL, MySqlParserFUNCTION, MySqlParserGENERAL, MySqlParserGLOBAL, MySqlParserGRANTS, MySqlParserGROUP_REPLICATION, MySqlParserHANDLER, MySqlParserHASH, MySqlParserHELP, MySqlParserHISTORY, MySqlParserHOST, MySqlParserHOSTS, MySqlParserIDENTIFIED, MySqlParserIGNORE_SERVER_IDS, MySqlParserIMPORT, MySqlParserINDEXES, MySqlParserINITIAL_SIZE, MySqlParserINPLACE, MySqlParserINSERT_METHOD, MySqlParserINSTALL, MySqlParserINSTANCE, MySqlParserINSTANT, MySqlParserINVISIBLE, MySqlParserINVOKER, MySqlParserIO, MySqlParserIO_THREAD, MySqlParserIPC, MySqlParserISOLATION, MySqlParserISSUER, MySqlParserJSON, MySqlParserKEY_BLOCK_SIZE, MySqlParserLANGUAGE, MySqlParserLAST, MySqlParserLEAVES, MySqlParserLESS, MySqlParserLEVEL, MySqlParserLIST, MySqlParserLOCAL, MySqlParserLOGFILE, MySqlParserLOGS, MySqlParserMASTER, MySqlParserMASTER_AUTO_POSITION, MySqlParserMASTER_CONNECT_RETRY, MySqlParserMASTER_DELAY, MySqlParserMASTER_HEARTBEAT_PERIOD, MySqlParserMASTER_HOST, MySqlParserMASTER_LOG_FILE, MySqlParserMASTER_LOG_POS, MySqlParserMASTER_PASSWORD, MySqlParserMASTER_PORT, MySqlParserMASTER_RETRY_COUNT, MySqlParserMASTER_SSL, MySqlParserMASTER_SSL_CA, MySqlParserMASTER_SSL_CAPATH, MySqlParserMASTER_SSL_CERT, MySqlParserMASTER_SSL_CIPHER, MySqlParserMASTER_SSL_CRL, MySqlParserMASTER_SSL_CRLPATH, MySqlParserMASTER_SSL_KEY, MySqlParserMASTER_TLS_VERSION, MySqlParserMASTER_USER, MySqlParserMAX_CONNECTIONS_PER_HOUR, MySqlParserMAX_QUERIES_PER_HOUR, MySqlParserMAX_ROWS, MySqlParserMAX_SIZE, MySqlParserMAX_UPDATES_PER_HOUR, MySqlParserMAX_USER_CONNECTIONS, MySqlParserMEDIUM, MySqlParserMEMBER, MySqlParserMERGE, MySqlParserMESSAGE_TEXT, MySqlParserMID, MySqlParserMIGRATE, MySqlParserMIN_ROWS, MySqlParserMODE, MySqlParserMODIFY, MySqlParserMUTEX, MySqlParserMYSQL, MySqlParserMYSQL_ERRNO, MySqlParserNAME, MySqlParserNAMES, MySqlParserNCHAR, MySqlParserNEVER, MySqlParserNEXT, MySqlParserNO, MySqlParserNOCOPY, MySqlParserNOWAIT, MySqlParserNODEGROUP, MySqlParserNONE, MySqlParserODBC, MySqlParserOFFLINE, MySqlParserOFFSET, MySqlParserOF, MySqlParserOJ, MySqlParserOLD_PASSWORD, MySqlParserONE, MySqlParserONLINE, MySqlParserONLY, MySqlParserOPEN, MySqlParserOPTIMIZER_COSTS, MySqlParserOPTIONS, MySqlParserOWNER, MySqlParserPACK_KEYS, MySqlParserPAGE, MySqlParserPARSER, MySqlParserPARTIAL, MySqlParserPARTITIONING, MySqlParserPARTITIONS, MySqlParserPASSWORD, MySqlParserPASSWORD_LOCK_TIME, MySqlParserPHASE, MySqlParserPLUGIN, MySqlParserPLUGIN_DIR, MySqlParserPLUGINS, MySqlParserPORT, MySqlParserPRECEDES, MySqlParserPREPARE, MySqlParserPRESERVE, MySqlParserPREV, MySqlParserPROCESSLIST, MySqlParserPROFILE, MySqlParserPROFILES, MySqlParserPROXY, MySqlParserQUERY, MySqlParserQUICK, MySqlParserREBUILD, MySqlParserRECOVER, MySqlParserRECURSIVE, MySqlParserREDO_BUFFER_SIZE, MySqlParserREDUNDANT, MySqlParserRELAY, MySqlParserRELAY_LOG_FILE, MySqlParserRELAY_LOG_POS, MySqlParserRELAYLOG, MySqlParserREMOVE, MySqlParserREORGANIZE, MySqlParserREPAIR, MySqlParserREPLICATE_DO_DB, MySqlParserREPLICATE_DO_TABLE, MySqlParserREPLICATE_IGNORE_DB, MySqlParserREPLICATE_IGNORE_TABLE, MySqlParserREPLICATE_REWRITE_DB, MySqlParserREPLICATE_WILD_DO_TABLE, MySqlParserREPLICATE_WILD_IGNORE_TABLE, MySqlParserREPLICATION, MySqlParserRESET, MySqlParserRESUME, MySqlParserRETURNED_SQLSTATE, MySqlParserRETURNING, MySqlParserRETURNS, MySqlParserREUSE, MySqlParserROLE, MySqlParserROLLBACK, MySqlParserROLLUP, MySqlParserROTATE, MySqlParserROW, MySqlParserROWS, MySqlParserROW_FORMAT, MySqlParserRTREE, MySqlParserSAVEPOINT, MySqlParserSCHEDULE, MySqlParserSECURITY, MySqlParserSERVER, MySqlParserSESSION, MySqlParserSHARE, MySqlParserSHARED, MySqlParserSIGNED, MySqlParserSIMPLE, MySqlParserSLAVE, MySqlParserSLOW, MySqlParserSNAPSHOT, MySqlParserSOCKET, MySqlParserSOME, MySqlParserSONAME, MySqlParserSOUNDS, MySqlParserSOURCE, MySqlParserSQL_AFTER_GTIDS, MySqlParserSQL_AFTER_MTS_GAPS, MySqlParserSQL_BEFORE_GTIDS, MySqlParserSQL_BUFFER_RESULT, MySqlParserSQL_CACHE, MySqlParserSQL_NO_CACHE, MySqlParserSQL_THREAD, MySqlParserSTART, MySqlParserSTARTS, MySqlParserSTATS_AUTO_RECALC, MySqlParserSTATS_PERSISTENT, MySqlParserSTATS_SAMPLE_PAGES, MySqlParserSTATUS, MySqlParserSTOP, MySqlParserSTORAGE, MySqlParserSTRING, MySqlParserSUBCLASS_ORIGIN, MySqlParserSUBJECT, MySqlParserSUBPARTITION, MySqlParserSUBPARTITIONS, MySqlParserSUSPEND, MySqlParserSWAPS, MySqlParserSWITCHES, MySqlParserTABLE_NAME, MySqlParserTABLESPACE, MySqlParserTABLE_TYPE, MySqlParserTEMPORARY, MySqlParserTEMPTABLE, MySqlParserTHAN, MySqlParserTRADITIONAL, MySqlParserTRANSACTION, MySqlParserTRANSACTIONAL, MySqlParserTRIGGERS, MySqlParserTRUNCATE, MySqlParserUNBOUNDED, MySqlParserUNDEFINED, MySqlParserUNDOFILE, MySqlParserUNDO_BUFFER_SIZE, MySqlParserUNINSTALL, MySqlParserUNKNOWN, MySqlParserUNTIL, MySqlParserUPGRADE, MySqlParserUSER, MySqlParserUSE_FRM, MySqlParserUSER_RESOURCES, MySqlParserVALIDATION, MySqlParserVALUE, MySqlParserVARIABLES, MySqlParserVIEW, MySqlParserVIRTUAL, MySqlParserVISIBLE, MySqlParserWAIT, MySqlParserWARNINGS, MySqlParserWITHOUT, MySqlParserWORK, MySqlParserWRAPPER, MySqlParserX509, MySqlParserXA, MySqlParserXML, MySqlParserYES, MySqlParserEUR, MySqlParserUSA, MySqlParserJIS, MySqlParserISO, MySqlParserINTERNAL, MySqlParserQUARTER, MySqlParserMONTH, MySqlParserDAY, MySqlParserHOUR, MySqlParserMINUTE, MySqlParserWEEK, MySqlParserSECOND, MySqlParserMICROSECOND, MySqlParserADMIN, MySqlParserAUDIT_ABORT_EXEMPT, MySqlParserAUDIT_ADMIN, MySqlParserAUTHENTICATION_POLICY_ADMIN, MySqlParserBACKUP_ADMIN, MySqlParserBINLOG_ADMIN, MySqlParserBINLOG_ENCRYPTION_ADMIN, MySqlParserCLONE_ADMIN, MySqlParserCONNECTION_ADMIN, MySqlParserENCRYPTION_KEY_ADMIN, MySqlParserEXECUTE, MySqlParserFILE, MySqlParserFIREWALL_ADMIN, MySqlParserFIREWALL_EXEMPT, MySqlParserFIREWALL_USER, MySqlParserGROUP_REPLICATION_ADMIN, MySqlParserINNODB_REDO_LOG_ARCHIVE, MySqlParserINVOKE, MySqlParserLAMBDA, MySqlParserNDB_STORED_USER, MySqlParserPASSWORDLESS_USER_ADMIN, MySqlParserPERSIST_RO_VARIABLES_ADMIN, MySqlParserPRIVILEGES, MySqlParserPROCESS, MySqlParserRELOAD, MySqlParserREPLICATION_APPLIER, MySqlParserREPLICATION_SLAVE_ADMIN, MySqlParserRESOURCE_GROUP_ADMIN, MySqlParserRESOURCE_GROUP_USER, MySqlParserROLE_ADMIN, MySqlParserROUTINE, MySqlParserS3, MySqlParserSESSION_VARIABLES_ADMIN, MySqlParserSET_USER_ID, MySqlParserSHOW_ROUTINE, MySqlParserSHUTDOWN, MySqlParserSUPER, MySqlParserSYSTEM_VARIABLES_ADMIN, MySqlParserTABLES, MySqlParserTABLE_ENCRYPTION_ADMIN, MySqlParserVERSION_TOKEN_ADMIN, MySqlParserXA_RECOVER_ADMIN, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserARCHIVE, MySqlParserBLACKHOLE, MySqlParserCSV, MySqlParserFEDERATED, MySqlParserINNODB, MySqlParserMEMORY, MySqlParserMRG_MYISAM, MySqlParserMYISAM, MySqlParserNDB, MySqlParserNDBCLUSTER, MySqlParserPERFORMANCE_SCHEMA, MySqlParserTOKUDB, MySqlParserREPEATABLE, MySqlParserCOMMITTED, MySqlParserUNCOMMITTED, MySqlParserSERIALIZABLE, MySqlParserGEOMETRYCOLLECTION, MySqlParserLINESTRING, MySqlParserMULTILINESTRING, MySqlParserMULTIPOINT, MySqlParserMULTIPOLYGON, MySqlParserPOINT, MySqlParserPOLYGON, MySqlParserABS, MySqlParserACOS, MySqlParserADDDATE, MySqlParserADDTIME, MySqlParserAES_DECRYPT, MySqlParserAES_ENCRYPT, MySqlParserAREA, MySqlParserASBINARY, MySqlParserASIN, MySqlParserASTEXT, MySqlParserASWKB, MySqlParserASWKT, MySqlParserASYMMETRIC_DECRYPT, MySqlParserASYMMETRIC_DERIVE, MySqlParserASYMMETRIC_ENCRYPT, MySqlParserASYMMETRIC_SIGN, MySqlParserASYMMETRIC_VERIFY, MySqlParserATAN, MySqlParserATAN2, MySqlParserBENCHMARK, MySqlParserBIN, MySqlParserBIT_COUNT, MySqlParserBIT_LENGTH, MySqlParserBUFFER, MySqlParserCATALOG_NAME, MySqlParserCEIL, MySqlParserCEILING, MySqlParserCENTROID, MySqlParserCHARACTER_LENGTH, MySqlParserCHARSET, MySqlParserCHAR_LENGTH, MySqlParserCOERCIBILITY, MySqlParserCOLLATION, MySqlParserCOMPRESS, MySqlParserCONCAT, MySqlParserCONCAT_WS, MySqlParserCONNECTION_ID, MySqlParserCONV, MySqlParserCONVERT_TZ, MySqlParserCOS, MySqlParserCOT, MySqlParserCRC32, MySqlParserCREATE_ASYMMETRIC_PRIV_KEY, MySqlParserCREATE_ASYMMETRIC_PUB_KEY, MySqlParserCREATE_DH_PARAMETERS, MySqlParserCREATE_DIGEST, MySqlParserCROSSES, MySqlParserDATEDIFF, MySqlParserDATE_FORMAT, MySqlParserDAYNAME, MySqlParserDAYOFMONTH, MySqlParserDAYOFWEEK, MySqlParserDAYOFYEAR, MySqlParserDECODE, MySqlParserDEGREES, MySqlParserDES_DECRYPT, MySqlParserDES_ENCRYPT, MySqlParserDIMENSION, MySqlParserDISJOINT, MySqlParserDISTANCE, MySqlParserELT, MySqlParserENCODE, MySqlParserENCRYPT, MySqlParserENDPOINT, MySqlParserENGINE_ATTRIBUTE, MySqlParserENVELOPE, MySqlParserEQUALS, MySqlParserEXP, MySqlParserEXPORT_SET, MySqlParserEXTERIORRING, MySqlParserEXTRACTVALUE, MySqlParserFIELD, MySqlParserFIND_IN_SET, MySqlParserFLOOR, MySqlParserFORMAT, MySqlParserFOUND_ROWS, MySqlParserFROM_BASE64, MySqlParserFROM_DAYS, MySqlParserFROM_UNIXTIME, MySqlParserGEOMCOLLFROMTEXT, MySqlParserGEOMCOLLFROMWKB, MySqlParserGEOMETRYCOLLECTIONFROMTEXT, MySqlParserGEOMETRYCOLLECTIONFROMWKB, MySqlParserGEOMETRYFROMTEXT, MySqlParserGEOMETRYFROMWKB, MySqlParserGEOMETRYN, MySqlParserGEOMETRYTYPE, MySqlParserGEOMFROMTEXT, MySqlParserGEOMFROMWKB, MySqlParserGET_FORMAT, MySqlParserGET_LOCK, MySqlParserGLENGTH, MySqlParserGREATEST, MySqlParserGTID_SUBSET, MySqlParserGTID_SUBTRACT, MySqlParserHEX, MySqlParserIFNULL, MySqlParserINET6_ATON, MySqlParserINET6_NTOA, MySqlParserINET_ATON, MySqlParserINET_NTOA, MySqlParserINSTR, MySqlParserINTERIORRINGN, MySqlParserINTERSECTS, MySqlParserISCLOSED, MySqlParserISEMPTY, MySqlParserISNULL, MySqlParserISSIMPLE, MySqlParserIS_FREE_LOCK, MySqlParserIS_IPV4, MySqlParserIS_IPV4_COMPAT, MySqlParserIS_IPV4_MAPPED, MySqlParserIS_IPV6, MySqlParserIS_USED_LOCK, MySqlParserLAST_INSERT_ID, MySqlParserLCASE, MySqlParserLEAST, MySqlParserLENGTH, MySqlParserLINEFROMTEXT, MySqlParserLINEFROMWKB, MySqlParserLINESTRINGFROMTEXT, MySqlParserLINESTRINGFROMWKB, MySqlParserLN, MySqlParserLOAD_FILE, MySqlParserLOCATE, MySqlParserLOG, MySqlParserLOG10, MySqlParserLOG2, MySqlParserLOWER, MySqlParserLPAD, MySqlParserLTRIM, MySqlParserMAKEDATE, MySqlParserMAKETIME, MySqlParserMAKE_SET, MySqlParserMASTER_POS_WAIT, MySqlParserMBRCONTAINS, MySqlParserMBRDISJOINT, MySqlParserMBREQUAL, MySqlParserMBRINTERSECTS, MySqlParserMBROVERLAPS, MySqlParserMBRTOUCHES, MySqlParserMBRWITHIN, MySqlParserMD5, MySqlParserMLINEFROMTEXT, MySqlParserMLINEFROMWKB, MySqlParserMONTHNAME, MySqlParserMPOINTFROMTEXT, MySqlParserMPOINTFROMWKB, MySqlParserMPOLYFROMTEXT, MySqlParserMPOLYFROMWKB, MySqlParserMULTILINESTRINGFROMTEXT, MySqlParserMULTILINESTRINGFROMWKB, MySqlParserMULTIPOINTFROMTEXT, MySqlParserMULTIPOINTFROMWKB, MySqlParserMULTIPOLYGONFROMTEXT, MySqlParserMULTIPOLYGONFROMWKB, MySqlParserNAME_CONST, MySqlParserNULLIF, MySqlParserNUMGEOMETRIES, MySqlParserNUMINTERIORRINGS, MySqlParserNUMPOINTS, MySqlParserOCT, MySqlParserOCTET_LENGTH, MySqlParserORD, MySqlParserOVERLAPS, MySqlParserPERIOD_ADD, MySqlParserPERIOD_DIFF, MySqlParserPI, MySqlParserPOINTFROMTEXT, MySqlParserPOINTFROMWKB, MySqlParserPOINTN, MySqlParserPOLYFROMTEXT, MySqlParserPOLYFROMWKB, MySqlParserPOLYGONFROMTEXT, MySqlParserPOLYGONFROMWKB, MySqlParserPOW, MySqlParserPOWER, MySqlParserQUOTE, MySqlParserRADIANS, MySqlParserRAND, MySqlParserRANDOM, MySqlParserRANDOM_BYTES, MySqlParserRELEASE_LOCK, MySqlParserREVERSE, MySqlParserROUND, MySqlParserROW_COUNT, MySqlParserRPAD, MySqlParserRTRIM, MySqlParserSEC_TO_TIME, MySqlParserSECONDARY_ENGINE_ATTRIBUTE, MySqlParserSESSION_USER, MySqlParserSHA, MySqlParserSHA1, MySqlParserSHA2, MySqlParserSCHEMA_NAME, MySqlParserSIGN, MySqlParserSIN, MySqlParserSLEEP, MySqlParserSOUNDEX, MySqlParserSQL_THREAD_WAIT_AFTER_GTIDS, MySqlParserSQRT, MySqlParserSRID, MySqlParserSTARTPOINT, MySqlParserSTRCMP, MySqlParserSTR_TO_DATE, MySqlParserST_AREA, MySqlParserST_ASBINARY, MySqlParserST_ASTEXT, MySqlParserST_ASWKB, MySqlParserST_ASWKT, MySqlParserST_BUFFER, MySqlParserST_CENTROID, MySqlParserST_CONTAINS, MySqlParserST_CROSSES, MySqlParserST_DIFFERENCE, MySqlParserST_DIMENSION, MySqlParserST_DISJOINT, MySqlParserST_DISTANCE, MySqlParserST_ENDPOINT, MySqlParserST_ENVELOPE, MySqlParserST_EQUALS, MySqlParserST_EXTERIORRING, MySqlParserST_GEOMCOLLFROMTEXT, MySqlParserST_GEOMCOLLFROMTXT, MySqlParserST_GEOMCOLLFROMWKB, MySqlParserST_GEOMETRYCOLLECTIONFROMTEXT, MySqlParserST_GEOMETRYCOLLECTIONFROMWKB, MySqlParserST_GEOMETRYFROMTEXT, MySqlParserST_GEOMETRYFROMWKB, MySqlParserST_GEOMETRYN, MySqlParserST_GEOMETRYTYPE, MySqlParserST_GEOMFROMTEXT, MySqlParserST_GEOMFROMWKB, MySqlParserST_INTERIORRINGN, MySqlParserST_INTERSECTION, MySqlParserST_INTERSECTS, MySqlParserST_ISCLOSED, MySqlParserST_ISEMPTY, MySqlParserST_ISSIMPLE, MySqlParserST_LINEFROMTEXT, MySqlParserST_LINEFROMWKB, MySqlParserST_LINESTRINGFROMTEXT, MySqlParserST_LINESTRINGFROMWKB, MySqlParserST_NUMGEOMETRIES, MySqlParserST_NUMINTERIORRING, MySqlParserST_NUMINTERIORRINGS, MySqlParserST_NUMPOINTS, MySqlParserST_OVERLAPS, MySqlParserST_POINTFROMTEXT, MySqlParserST_POINTFROMWKB, MySqlParserST_POINTN, MySqlParserST_POLYFROMTEXT, MySqlParserST_POLYFROMWKB, MySqlParserST_POLYGONFROMTEXT, MySqlParserST_POLYGONFROMWKB, MySqlParserST_SRID, MySqlParserST_STARTPOINT, MySqlParserST_SYMDIFFERENCE, MySqlParserST_TOUCHES, MySqlParserST_UNION, MySqlParserST_WITHIN, MySqlParserST_X, MySqlParserST_Y, MySqlParserSTRING_TO_VECTOR, MySqlParserSUBDATE, MySqlParserSUBSTRING_INDEX, MySqlParserSUBTIME, MySqlParserSYSTEM_USER, MySqlParserTAN, MySqlParserTIMEDIFF, MySqlParserTIMESTAMPADD, MySqlParserTIMESTAMPDIFF, MySqlParserTIME_FORMAT, MySqlParserTIME_TO_SEC, MySqlParserTOUCHES, MySqlParserTO_BASE64, MySqlParserTO_DAYS, MySqlParserTO_SECONDS, MySqlParserTP_CONNECTION_ADMIN, MySqlParserUCASE, MySqlParserUNCOMPRESS, MySqlParserUNCOMPRESSED_LENGTH, MySqlParserUNHEX, MySqlParserUNIX_TIMESTAMP, MySqlParserUPDATEXML, MySqlParserUPPER, MySqlParserUUID, MySqlParserUUID_SHORT, MySqlParserVALIDATE_PASSWORD_STRENGTH, MySqlParserVECTOR_DIM, MySqlParserVECTOR_TO_STRING, MySqlParserVERSION, MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS, MySqlParserWEEKDAY, MySqlParserWEEKOFYEAR, MySqlParserWEIGHT_STRING, MySqlParserWITHIN, MySqlParserYEARWEEK, MySqlParserY_FUNCTION, MySqlParserX_FUNCTION, MySqlParserMOD, MySqlParserCHARSET_REVERSE_QOUTE_STRING, MySqlParserSTRING_LITERAL, MySqlParserID: + { + p.SetState(6133) + + var _x = p.UidList() + + localctx.(*LoadedTableIndexesContext).partitionList = _x + } + + case MySqlParserALL: + { + p.SetState(6134) + p.Match(MySqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(6137) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(6147) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 900, p.GetParserRuleContext()) == 1 { + p.SetState(6141) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserINDEX || _la == MySqlParserKEY { + { + p.SetState(6140) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*LoadedTableIndexesContext).indexFormat = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserINDEX || _la == MySqlParserKEY) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*LoadedTableIndexesContext).indexFormat = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(6143) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6144) + + var _x = p.UidList() + + localctx.(*LoadedTableIndexesContext).indexList = _x + } + { + p.SetState(6145) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6151) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserIGNORE { + { + p.SetState(6149) + p.Match(MySqlParserIGNORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6150) + p.Match(MySqlParserLEAVES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISimpleDescribeStatementContext is an interface to support dynamic dispatch. +type ISimpleDescribeStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetCommand returns the command token. + GetCommand() antlr.Token + + // GetPattern returns the pattern token. + GetPattern() antlr.Token + + // SetCommand sets the command token. + SetCommand(antlr.Token) + + // SetPattern sets the pattern token. + SetPattern(antlr.Token) + + // GetColumn returns the column rule contexts. + GetColumn() IUidContext + + // SetColumn sets the column rule contexts. + SetColumn(IUidContext) + + // Getter signatures + TableName() ITableNameContext + EXPLAIN() antlr.TerminalNode + DESCRIBE() antlr.TerminalNode + DESC() antlr.TerminalNode + Uid() IUidContext + STRING_LITERAL() antlr.TerminalNode + + // IsSimpleDescribeStatementContext differentiates from other interfaces. + IsSimpleDescribeStatementContext() +} + +type SimpleDescribeStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + command antlr.Token + column IUidContext + pattern antlr.Token +} + +func NewEmptySimpleDescribeStatementContext() *SimpleDescribeStatementContext { + var p = new(SimpleDescribeStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_simpleDescribeStatement + return p +} + +func InitEmptySimpleDescribeStatementContext(p *SimpleDescribeStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_simpleDescribeStatement +} + +func (*SimpleDescribeStatementContext) IsSimpleDescribeStatementContext() {} + +func NewSimpleDescribeStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SimpleDescribeStatementContext { + var p = new(SimpleDescribeStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_simpleDescribeStatement + + return p +} + +func (s *SimpleDescribeStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *SimpleDescribeStatementContext) GetCommand() antlr.Token { return s.command } + +func (s *SimpleDescribeStatementContext) GetPattern() antlr.Token { return s.pattern } + +func (s *SimpleDescribeStatementContext) SetCommand(v antlr.Token) { s.command = v } + +func (s *SimpleDescribeStatementContext) SetPattern(v antlr.Token) { s.pattern = v } + +func (s *SimpleDescribeStatementContext) GetColumn() IUidContext { return s.column } + +func (s *SimpleDescribeStatementContext) SetColumn(v IUidContext) { s.column = v } + +func (s *SimpleDescribeStatementContext) TableName() ITableNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableNameContext) +} + +func (s *SimpleDescribeStatementContext) EXPLAIN() antlr.TerminalNode { + return s.GetToken(MySqlParserEXPLAIN, 0) +} + +func (s *SimpleDescribeStatementContext) DESCRIBE() antlr.TerminalNode { + return s.GetToken(MySqlParserDESCRIBE, 0) +} + +func (s *SimpleDescribeStatementContext) DESC() antlr.TerminalNode { + return s.GetToken(MySqlParserDESC, 0) +} + +func (s *SimpleDescribeStatementContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *SimpleDescribeStatementContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *SimpleDescribeStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SimpleDescribeStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SimpleDescribeStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSimpleDescribeStatement(s) + } +} + +func (s *SimpleDescribeStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSimpleDescribeStatement(s) + } +} + +func (p *MySqlParser) SimpleDescribeStatement() (localctx ISimpleDescribeStatementContext) { + localctx = NewSimpleDescribeStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 526, MySqlParserRULE_simpleDescribeStatement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6153) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*SimpleDescribeStatementContext).command = _lt + + _la = p.GetTokenStream().LA(1) + + if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&4611791571543654400) != 0) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*SimpleDescribeStatementContext).command = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(6154) + p.TableName() + } + p.SetState(6157) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 902, p.GetParserRuleContext()) == 1 { + { + p.SetState(6155) + + var _x = p.Uid() + + localctx.(*SimpleDescribeStatementContext).column = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 902, p.GetParserRuleContext()) == 2 { + { + p.SetState(6156) + + var _m = p.Match(MySqlParserSTRING_LITERAL) + + localctx.(*SimpleDescribeStatementContext).pattern = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFullDescribeStatementContext is an interface to support dynamic dispatch. +type IFullDescribeStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetCommand returns the command token. + GetCommand() antlr.Token + + // GetFormatType returns the formatType token. + GetFormatType() antlr.Token + + // GetFormatValue returns the formatValue token. + GetFormatValue() antlr.Token + + // SetCommand sets the command token. + SetCommand(antlr.Token) + + // SetFormatType sets the formatType token. + SetFormatType(antlr.Token) + + // SetFormatValue sets the formatValue token. + SetFormatValue(antlr.Token) + + // Getter signatures + DescribeObjectClause() IDescribeObjectClauseContext + EXPLAIN() antlr.TerminalNode + DESCRIBE() antlr.TerminalNode + DESC() antlr.TerminalNode + EQUAL_SYMBOL() antlr.TerminalNode + EXTENDED() antlr.TerminalNode + PARTITIONS() antlr.TerminalNode + FORMAT() antlr.TerminalNode + TRADITIONAL() antlr.TerminalNode + JSON() antlr.TerminalNode + + // IsFullDescribeStatementContext differentiates from other interfaces. + IsFullDescribeStatementContext() +} + +type FullDescribeStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + command antlr.Token + formatType antlr.Token + formatValue antlr.Token +} + +func NewEmptyFullDescribeStatementContext() *FullDescribeStatementContext { + var p = new(FullDescribeStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_fullDescribeStatement + return p +} + +func InitEmptyFullDescribeStatementContext(p *FullDescribeStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_fullDescribeStatement +} + +func (*FullDescribeStatementContext) IsFullDescribeStatementContext() {} + +func NewFullDescribeStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FullDescribeStatementContext { + var p = new(FullDescribeStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_fullDescribeStatement + + return p +} + +func (s *FullDescribeStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *FullDescribeStatementContext) GetCommand() antlr.Token { return s.command } + +func (s *FullDescribeStatementContext) GetFormatType() antlr.Token { return s.formatType } + +func (s *FullDescribeStatementContext) GetFormatValue() antlr.Token { return s.formatValue } + +func (s *FullDescribeStatementContext) SetCommand(v antlr.Token) { s.command = v } + +func (s *FullDescribeStatementContext) SetFormatType(v antlr.Token) { s.formatType = v } + +func (s *FullDescribeStatementContext) SetFormatValue(v antlr.Token) { s.formatValue = v } + +func (s *FullDescribeStatementContext) DescribeObjectClause() IDescribeObjectClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribeObjectClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribeObjectClauseContext) +} + +func (s *FullDescribeStatementContext) EXPLAIN() antlr.TerminalNode { + return s.GetToken(MySqlParserEXPLAIN, 0) +} + +func (s *FullDescribeStatementContext) DESCRIBE() antlr.TerminalNode { + return s.GetToken(MySqlParserDESCRIBE, 0) +} + +func (s *FullDescribeStatementContext) DESC() antlr.TerminalNode { + return s.GetToken(MySqlParserDESC, 0) +} + +func (s *FullDescribeStatementContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *FullDescribeStatementContext) EXTENDED() antlr.TerminalNode { + return s.GetToken(MySqlParserEXTENDED, 0) +} + +func (s *FullDescribeStatementContext) PARTITIONS() antlr.TerminalNode { + return s.GetToken(MySqlParserPARTITIONS, 0) +} + +func (s *FullDescribeStatementContext) FORMAT() antlr.TerminalNode { + return s.GetToken(MySqlParserFORMAT, 0) +} + +func (s *FullDescribeStatementContext) TRADITIONAL() antlr.TerminalNode { + return s.GetToken(MySqlParserTRADITIONAL, 0) +} + +func (s *FullDescribeStatementContext) JSON() antlr.TerminalNode { + return s.GetToken(MySqlParserJSON, 0) +} + +func (s *FullDescribeStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FullDescribeStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FullDescribeStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterFullDescribeStatement(s) + } +} + +func (s *FullDescribeStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitFullDescribeStatement(s) + } +} + +func (p *MySqlParser) FullDescribeStatement() (localctx IFullDescribeStatementContext) { + localctx = NewFullDescribeStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 528, MySqlParserRULE_fullDescribeStatement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6159) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*FullDescribeStatementContext).command = _lt + + _la = p.GetTokenStream().LA(1) + + if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&4611791571543654400) != 0) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*FullDescribeStatementContext).command = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(6163) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserEXTENDED || _la == MySqlParserPARTITIONS || _la == MySqlParserFORMAT { + { + p.SetState(6160) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*FullDescribeStatementContext).formatType = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserEXTENDED || _la == MySqlParserPARTITIONS || _la == MySqlParserFORMAT) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*FullDescribeStatementContext).formatType = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(6161) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6162) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*FullDescribeStatementContext).formatValue = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserJSON || _la == MySqlParserTRADITIONAL) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*FullDescribeStatementContext).formatValue = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(6165) + p.DescribeObjectClause() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHelpStatementContext is an interface to support dynamic dispatch. +type IHelpStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + HELP() antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + + // IsHelpStatementContext differentiates from other interfaces. + IsHelpStatementContext() +} + +type HelpStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHelpStatementContext() *HelpStatementContext { + var p = new(HelpStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_helpStatement + return p +} + +func InitEmptyHelpStatementContext(p *HelpStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_helpStatement +} + +func (*HelpStatementContext) IsHelpStatementContext() {} + +func NewHelpStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *HelpStatementContext { + var p = new(HelpStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_helpStatement + + return p +} + +func (s *HelpStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *HelpStatementContext) HELP() antlr.TerminalNode { + return s.GetToken(MySqlParserHELP, 0) +} + +func (s *HelpStatementContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *HelpStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *HelpStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *HelpStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterHelpStatement(s) + } +} + +func (s *HelpStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitHelpStatement(s) + } +} + +func (p *MySqlParser) HelpStatement() (localctx IHelpStatementContext) { + localctx = NewHelpStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 530, MySqlParserRULE_helpStatement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6167) + p.Match(MySqlParserHELP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6168) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUseStatementContext is an interface to support dynamic dispatch. +type IUseStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + USE() antlr.TerminalNode + Uid() IUidContext + + // IsUseStatementContext differentiates from other interfaces. + IsUseStatementContext() +} + +type UseStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUseStatementContext() *UseStatementContext { + var p = new(UseStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_useStatement + return p +} + +func InitEmptyUseStatementContext(p *UseStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_useStatement +} + +func (*UseStatementContext) IsUseStatementContext() {} + +func NewUseStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UseStatementContext { + var p = new(UseStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_useStatement + + return p +} + +func (s *UseStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *UseStatementContext) USE() antlr.TerminalNode { + return s.GetToken(MySqlParserUSE, 0) +} + +func (s *UseStatementContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *UseStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UseStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *UseStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterUseStatement(s) + } +} + +func (s *UseStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitUseStatement(s) + } +} + +func (p *MySqlParser) UseStatement() (localctx IUseStatementContext) { + localctx = NewUseStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 532, MySqlParserRULE_useStatement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6170) + p.Match(MySqlParserUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6171) + p.Uid() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISignalStatementContext is an interface to support dynamic dispatch. +type ISignalStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SIGNAL() antlr.TerminalNode + ID() antlr.TerminalNode + REVERSE_QUOTE_ID() antlr.TerminalNode + SET() antlr.TerminalNode + AllSignalConditionInformation() []ISignalConditionInformationContext + SignalConditionInformation(i int) ISignalConditionInformationContext + SQLSTATE() antlr.TerminalNode + StringLiteral() IStringLiteralContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + VALUE() antlr.TerminalNode + + // IsSignalStatementContext differentiates from other interfaces. + IsSignalStatementContext() +} + +type SignalStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySignalStatementContext() *SignalStatementContext { + var p = new(SignalStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_signalStatement + return p +} + +func InitEmptySignalStatementContext(p *SignalStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_signalStatement +} + +func (*SignalStatementContext) IsSignalStatementContext() {} + +func NewSignalStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SignalStatementContext { + var p = new(SignalStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_signalStatement + + return p +} + +func (s *SignalStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *SignalStatementContext) SIGNAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSIGNAL, 0) +} + +func (s *SignalStatementContext) ID() antlr.TerminalNode { + return s.GetToken(MySqlParserID, 0) +} + +func (s *SignalStatementContext) REVERSE_QUOTE_ID() antlr.TerminalNode { + return s.GetToken(MySqlParserREVERSE_QUOTE_ID, 0) +} + +func (s *SignalStatementContext) SET() antlr.TerminalNode { + return s.GetToken(MySqlParserSET, 0) +} + +func (s *SignalStatementContext) AllSignalConditionInformation() []ISignalConditionInformationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISignalConditionInformationContext); ok { + len++ + } + } + + tst := make([]ISignalConditionInformationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISignalConditionInformationContext); ok { + tst[i] = t.(ISignalConditionInformationContext) + i++ + } + } + + return tst +} + +func (s *SignalStatementContext) SignalConditionInformation(i int) ISignalConditionInformationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISignalConditionInformationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISignalConditionInformationContext) +} + +func (s *SignalStatementContext) SQLSTATE() antlr.TerminalNode { + return s.GetToken(MySqlParserSQLSTATE, 0) +} + +func (s *SignalStatementContext) StringLiteral() IStringLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringLiteralContext) +} + +func (s *SignalStatementContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *SignalStatementContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *SignalStatementContext) VALUE() antlr.TerminalNode { + return s.GetToken(MySqlParserVALUE, 0) +} + +func (s *SignalStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SignalStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SignalStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSignalStatement(s) + } +} + +func (s *SignalStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSignalStatement(s) + } +} + +func (p *MySqlParser) SignalStatement() (localctx ISignalStatementContext) { + localctx = NewSignalStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 534, MySqlParserRULE_signalStatement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6173) + p.Match(MySqlParserSIGNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6181) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserSQLSTATE: + { + p.SetState(6174) + p.Match(MySqlParserSQLSTATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6176) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserVALUE { + { + p.SetState(6175) + p.Match(MySqlParserVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6178) + p.StringLiteral() + } + + case MySqlParserID: + { + p.SetState(6179) + p.Match(MySqlParserID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserREVERSE_QUOTE_ID: + { + p.SetState(6180) + p.Match(MySqlParserREVERSE_QUOTE_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(6192) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 907, p.GetParserRuleContext()) == 1 { + { + p.SetState(6183) + p.Match(MySqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6184) + p.SignalConditionInformation() + } + p.SetState(6189) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(6185) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6186) + p.SignalConditionInformation() + } + + p.SetState(6191) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IResignalStatementContext is an interface to support dynamic dispatch. +type IResignalStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RESIGNAL() antlr.TerminalNode + ID() antlr.TerminalNode + REVERSE_QUOTE_ID() antlr.TerminalNode + SET() antlr.TerminalNode + AllSignalConditionInformation() []ISignalConditionInformationContext + SignalConditionInformation(i int) ISignalConditionInformationContext + SQLSTATE() antlr.TerminalNode + StringLiteral() IStringLiteralContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + VALUE() antlr.TerminalNode + + // IsResignalStatementContext differentiates from other interfaces. + IsResignalStatementContext() +} + +type ResignalStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyResignalStatementContext() *ResignalStatementContext { + var p = new(ResignalStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_resignalStatement + return p +} + +func InitEmptyResignalStatementContext(p *ResignalStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_resignalStatement +} + +func (*ResignalStatementContext) IsResignalStatementContext() {} + +func NewResignalStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ResignalStatementContext { + var p = new(ResignalStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_resignalStatement + + return p +} + +func (s *ResignalStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *ResignalStatementContext) RESIGNAL() antlr.TerminalNode { + return s.GetToken(MySqlParserRESIGNAL, 0) +} + +func (s *ResignalStatementContext) ID() antlr.TerminalNode { + return s.GetToken(MySqlParserID, 0) +} + +func (s *ResignalStatementContext) REVERSE_QUOTE_ID() antlr.TerminalNode { + return s.GetToken(MySqlParserREVERSE_QUOTE_ID, 0) +} + +func (s *ResignalStatementContext) SET() antlr.TerminalNode { + return s.GetToken(MySqlParserSET, 0) +} + +func (s *ResignalStatementContext) AllSignalConditionInformation() []ISignalConditionInformationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISignalConditionInformationContext); ok { + len++ + } + } + + tst := make([]ISignalConditionInformationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISignalConditionInformationContext); ok { + tst[i] = t.(ISignalConditionInformationContext) + i++ + } + } + + return tst +} + +func (s *ResignalStatementContext) SignalConditionInformation(i int) ISignalConditionInformationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISignalConditionInformationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISignalConditionInformationContext) +} + +func (s *ResignalStatementContext) SQLSTATE() antlr.TerminalNode { + return s.GetToken(MySqlParserSQLSTATE, 0) +} + +func (s *ResignalStatementContext) StringLiteral() IStringLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringLiteralContext) +} + +func (s *ResignalStatementContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *ResignalStatementContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *ResignalStatementContext) VALUE() antlr.TerminalNode { + return s.GetToken(MySqlParserVALUE, 0) +} + +func (s *ResignalStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ResignalStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ResignalStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterResignalStatement(s) + } +} + +func (s *ResignalStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitResignalStatement(s) + } +} + +func (p *MySqlParser) ResignalStatement() (localctx IResignalStatementContext) { + localctx = NewResignalStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 536, MySqlParserRULE_resignalStatement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6194) + p.Match(MySqlParserRESIGNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6202) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case MySqlParserSQLSTATE: + { + p.SetState(6195) + p.Match(MySqlParserSQLSTATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6197) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserVALUE { + { + p.SetState(6196) + p.Match(MySqlParserVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6199) + p.StringLiteral() + } + + case MySqlParserID: + { + p.SetState(6200) + p.Match(MySqlParserID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserREVERSE_QUOTE_ID: + { + p.SetState(6201) + p.Match(MySqlParserREVERSE_QUOTE_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserEOF, MySqlParserALTER, MySqlParserANALYZE, MySqlParserCALL, MySqlParserCHANGE, MySqlParserCHECK, MySqlParserCREATE, MySqlParserDELETE, MySqlParserDESC, MySqlParserDESCRIBE, MySqlParserDROP, MySqlParserEXPLAIN, MySqlParserGET, MySqlParserGRANT, MySqlParserINSERT, MySqlParserKILL, MySqlParserLOAD, MySqlParserLOCK, MySqlParserOPTIMIZE, MySqlParserPURGE, MySqlParserRELEASE, MySqlParserRENAME, MySqlParserREPLACE, MySqlParserRESIGNAL, MySqlParserREVOKE, MySqlParserSELECT, MySqlParserSET, MySqlParserSHOW, MySqlParserSIGNAL, MySqlParserTABLE, MySqlParserUNLOCK, MySqlParserUPDATE, MySqlParserUSE, MySqlParserVALUES, MySqlParserWITH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserCACHE, MySqlParserCHECKSUM, MySqlParserCOMMIT, MySqlParserDEALLOCATE, MySqlParserDO, MySqlParserFLUSH, MySqlParserHANDLER, MySqlParserHELP, MySqlParserINSTALL, MySqlParserPREPARE, MySqlParserREPAIR, MySqlParserRESET, MySqlParserROLLBACK, MySqlParserSAVEPOINT, MySqlParserSTART, MySqlParserSTOP, MySqlParserTRUNCATE, MySqlParserUNINSTALL, MySqlParserXA, MySqlParserEXECUTE, MySqlParserSHUTDOWN, MySqlParserMINUS, MySqlParserLR_BRACKET, MySqlParserSEMI: + + default: + } + p.SetState(6213) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 911, p.GetParserRuleContext()) == 1 { + { + p.SetState(6204) + p.Match(MySqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6205) + p.SignalConditionInformation() + } + p.SetState(6210) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(6206) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6207) + p.SignalConditionInformation() + } + + p.SetState(6212) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISignalConditionInformationContext is an interface to support dynamic dispatch. +type ISignalConditionInformationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EQUAL_SYMBOL() antlr.TerminalNode + CLASS_ORIGIN() antlr.TerminalNode + SUBCLASS_ORIGIN() antlr.TerminalNode + MESSAGE_TEXT() antlr.TerminalNode + MYSQL_ERRNO() antlr.TerminalNode + CONSTRAINT_CATALOG() antlr.TerminalNode + CONSTRAINT_SCHEMA() antlr.TerminalNode + CONSTRAINT_NAME() antlr.TerminalNode + CATALOG_NAME() antlr.TerminalNode + SCHEMA_NAME() antlr.TerminalNode + TABLE_NAME() antlr.TerminalNode + COLUMN_NAME() antlr.TerminalNode + CURSOR_NAME() antlr.TerminalNode + StringLiteral() IStringLiteralContext + DECIMAL_LITERAL() antlr.TerminalNode + MysqlVariable() IMysqlVariableContext + SimpleId() ISimpleIdContext + + // IsSignalConditionInformationContext differentiates from other interfaces. + IsSignalConditionInformationContext() +} + +type SignalConditionInformationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySignalConditionInformationContext() *SignalConditionInformationContext { + var p = new(SignalConditionInformationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_signalConditionInformation + return p +} + +func InitEmptySignalConditionInformationContext(p *SignalConditionInformationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_signalConditionInformation +} + +func (*SignalConditionInformationContext) IsSignalConditionInformationContext() {} + +func NewSignalConditionInformationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SignalConditionInformationContext { + var p = new(SignalConditionInformationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_signalConditionInformation + + return p +} + +func (s *SignalConditionInformationContext) GetParser() antlr.Parser { return s.parser } + +func (s *SignalConditionInformationContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *SignalConditionInformationContext) CLASS_ORIGIN() antlr.TerminalNode { + return s.GetToken(MySqlParserCLASS_ORIGIN, 0) +} + +func (s *SignalConditionInformationContext) SUBCLASS_ORIGIN() antlr.TerminalNode { + return s.GetToken(MySqlParserSUBCLASS_ORIGIN, 0) +} + +func (s *SignalConditionInformationContext) MESSAGE_TEXT() antlr.TerminalNode { + return s.GetToken(MySqlParserMESSAGE_TEXT, 0) +} + +func (s *SignalConditionInformationContext) MYSQL_ERRNO() antlr.TerminalNode { + return s.GetToken(MySqlParserMYSQL_ERRNO, 0) +} + +func (s *SignalConditionInformationContext) CONSTRAINT_CATALOG() antlr.TerminalNode { + return s.GetToken(MySqlParserCONSTRAINT_CATALOG, 0) +} + +func (s *SignalConditionInformationContext) CONSTRAINT_SCHEMA() antlr.TerminalNode { + return s.GetToken(MySqlParserCONSTRAINT_SCHEMA, 0) +} + +func (s *SignalConditionInformationContext) CONSTRAINT_NAME() antlr.TerminalNode { + return s.GetToken(MySqlParserCONSTRAINT_NAME, 0) +} + +func (s *SignalConditionInformationContext) CATALOG_NAME() antlr.TerminalNode { + return s.GetToken(MySqlParserCATALOG_NAME, 0) +} + +func (s *SignalConditionInformationContext) SCHEMA_NAME() antlr.TerminalNode { + return s.GetToken(MySqlParserSCHEMA_NAME, 0) +} + +func (s *SignalConditionInformationContext) TABLE_NAME() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLE_NAME, 0) +} + +func (s *SignalConditionInformationContext) COLUMN_NAME() antlr.TerminalNode { + return s.GetToken(MySqlParserCOLUMN_NAME, 0) +} + +func (s *SignalConditionInformationContext) CURSOR_NAME() antlr.TerminalNode { + return s.GetToken(MySqlParserCURSOR_NAME, 0) +} + +func (s *SignalConditionInformationContext) StringLiteral() IStringLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringLiteralContext) +} + +func (s *SignalConditionInformationContext) DECIMAL_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserDECIMAL_LITERAL, 0) +} + +func (s *SignalConditionInformationContext) MysqlVariable() IMysqlVariableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMysqlVariableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMysqlVariableContext) +} + +func (s *SignalConditionInformationContext) SimpleId() ISimpleIdContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimpleIdContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISimpleIdContext) +} + +func (s *SignalConditionInformationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SignalConditionInformationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SignalConditionInformationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSignalConditionInformation(s) + } +} + +func (s *SignalConditionInformationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSignalConditionInformation(s) + } +} + +func (p *MySqlParser) SignalConditionInformation() (localctx ISignalConditionInformationContext) { + localctx = NewSignalConditionInformationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 538, MySqlParserRULE_signalConditionInformation) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6215) + _la = p.GetTokenStream().LA(1) + + if !(((int64((_la-360)) & ^0x3f) == 0 && ((int64(1)<<(_la-360))&272105729) != 0) || _la == MySqlParserMESSAGE_TEXT || _la == MySqlParserMYSQL_ERRNO || _la == MySqlParserSUBCLASS_ORIGIN || _la == MySqlParserTABLE_NAME || _la == MySqlParserCATALOG_NAME || _la == MySqlParserSCHEMA_NAME) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(6216) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6221) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserSTART_NATIONAL_STRING_LITERAL, MySqlParserSTRING_LITERAL, MySqlParserSTRING_CHARSET_NAME: + { + p.SetState(6217) + p.StringLiteral() + } + + case MySqlParserDECIMAL_LITERAL: + { + p.SetState(6218) + p.Match(MySqlParserDECIMAL_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserLOCAL_ID, MySqlParserGLOBAL_ID: + { + p.SetState(6219) + p.MysqlVariable() + } + + case MySqlParserARRAY, MySqlParserATTRIBUTE, MySqlParserBUCKETS, MySqlParserCONDITION, MySqlParserCURRENT, MySqlParserCURRENT_USER, MySqlParserDATABASE, MySqlParserDEFAULT, MySqlParserDIAGNOSTICS, MySqlParserEMPTY, MySqlParserENFORCED, MySqlParserEXCEPT, MySqlParserGROUP, MySqlParserIF, MySqlParserIGNORED, MySqlParserINSERT, MySqlParserLATERAL, MySqlParserLEFT, MySqlParserNUMBER, MySqlParserOPTIONAL, MySqlParserORDER, MySqlParserPRIMARY, MySqlParserREPEAT, MySqlParserREPLACE, MySqlParserRIGHT, MySqlParserSCHEMA, MySqlParserSKIP_QUERY_REWRITE, MySqlParserSTACKED, MySqlParserSTATEMENT, MySqlParserDATE, MySqlParserTIME, MySqlParserTIMESTAMP, MySqlParserDATETIME, MySqlParserYEAR, MySqlParserBINARY, MySqlParserTEXT, MySqlParserENUM, MySqlParserSERIAL, MySqlParserJSON_ARRAY, MySqlParserJSON_ARRAYAGG, MySqlParserJSON_ARRAY_APPEND, MySqlParserJSON_ARRAY_INSERT, MySqlParserJSON_CONTAINS, MySqlParserJSON_CONTAINS_PATH, MySqlParserJSON_DEPTH, MySqlParserJSON_EXTRACT, MySqlParserJSON_INSERT, MySqlParserJSON_KEYS, MySqlParserJSON_LENGTH, MySqlParserJSON_MERGE, MySqlParserJSON_MERGE_PATCH, MySqlParserJSON_MERGE_PRESERVE, MySqlParserJSON_OBJECT, MySqlParserJSON_OBJECTAGG, MySqlParserJSON_OVERLAPS, MySqlParserJSON_PRETTY, MySqlParserJSON_QUOTE, MySqlParserJSON_REMOVE, MySqlParserJSON_REPLACE, MySqlParserJSON_SCHEMA_VALID, MySqlParserJSON_SCHEMA_VALIDATION_REPORT, MySqlParserJSON_SEARCH, MySqlParserJSON_SET, MySqlParserJSON_STORAGE_FREE, MySqlParserJSON_STORAGE_SIZE, MySqlParserJSON_TABLE, MySqlParserJSON_TYPE, MySqlParserJSON_UNQUOTE, MySqlParserJSON_VALID, MySqlParserJSON_VALUE, MySqlParserNESTED, MySqlParserORDINALITY, MySqlParserPATH, MySqlParserAVG, MySqlParserBIT_AND, MySqlParserBIT_OR, MySqlParserBIT_XOR, MySqlParserCOUNT, MySqlParserCUME_DIST, MySqlParserDENSE_RANK, MySqlParserFIRST_VALUE, MySqlParserGROUP_CONCAT, MySqlParserLAG, MySqlParserLAST_VALUE, MySqlParserLEAD, MySqlParserMAX, MySqlParserMIN, MySqlParserNTILE, MySqlParserNTH_VALUE, MySqlParserPERCENT_RANK, MySqlParserRANK, MySqlParserROW_NUMBER, MySqlParserSTD, MySqlParserSTDDEV, MySqlParserSTDDEV_POP, MySqlParserSTDDEV_SAMP, MySqlParserSUM, MySqlParserVAR_POP, MySqlParserVAR_SAMP, MySqlParserVARIANCE, MySqlParserCURRENT_DATE, MySqlParserCURRENT_TIME, MySqlParserCURRENT_TIMESTAMP, MySqlParserLOCALTIME, MySqlParserCURDATE, MySqlParserCURTIME, MySqlParserDATE_ADD, MySqlParserDATE_SUB, MySqlParserLOCALTIMESTAMP, MySqlParserNOW, MySqlParserPOSITION, MySqlParserSUBSTR, MySqlParserSUBSTRING, MySqlParserSYSDATE, MySqlParserTRIM, MySqlParserUTC_DATE, MySqlParserUTC_TIME, MySqlParserUTC_TIMESTAMP, MySqlParserACCOUNT, MySqlParserACTION, MySqlParserAFTER, MySqlParserAGGREGATE, MySqlParserALGORITHM, MySqlParserANY, MySqlParserAT, MySqlParserAUTHORS, MySqlParserAUTOCOMMIT, MySqlParserAUTOEXTEND_SIZE, MySqlParserAUTO_INCREMENT, MySqlParserAVG_ROW_LENGTH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserBIT, MySqlParserBLOCK, MySqlParserBOOL, MySqlParserBOOLEAN, MySqlParserBTREE, MySqlParserCACHE, MySqlParserCASCADED, MySqlParserCHAIN, MySqlParserCHANGED, MySqlParserCHANNEL, MySqlParserCHECKSUM, MySqlParserPAGE_CHECKSUM, MySqlParserCIPHER, MySqlParserCLASS_ORIGIN, MySqlParserCLIENT, MySqlParserCLOSE, MySqlParserCLUSTERING, MySqlParserCOALESCE, MySqlParserCODE, MySqlParserCOLUMNS, MySqlParserCOLUMN_FORMAT, MySqlParserCOLUMN_NAME, MySqlParserCOMMENT, MySqlParserCOMMIT, MySqlParserCOMPACT, MySqlParserCOMPLETION, MySqlParserCOMPRESSED, MySqlParserCOMPRESSION, MySqlParserCONCURRENT, MySqlParserCONNECT, MySqlParserCONNECTION, MySqlParserCONSISTENT, MySqlParserCONSTRAINT_CATALOG, MySqlParserCONSTRAINT_SCHEMA, MySqlParserCONSTRAINT_NAME, MySqlParserCONTAINS, MySqlParserCONTEXT, MySqlParserCONTRIBUTORS, MySqlParserCOPY, MySqlParserCPU, MySqlParserCURSOR_NAME, MySqlParserDATA, MySqlParserDATAFILE, MySqlParserDEALLOCATE, MySqlParserDEFAULT_AUTH, MySqlParserDEFINER, MySqlParserDELAY_KEY_WRITE, MySqlParserDES_KEY_FILE, MySqlParserDIRECTORY, MySqlParserDISABLE, MySqlParserDISCARD, MySqlParserDISK, MySqlParserDO, MySqlParserDUMPFILE, MySqlParserDUPLICATE, MySqlParserDYNAMIC, MySqlParserENABLE, MySqlParserENCRYPTION, MySqlParserEND, MySqlParserENDS, MySqlParserENGINE, MySqlParserENGINES, MySqlParserERROR, MySqlParserERRORS, MySqlParserESCAPE, MySqlParserEVEN, MySqlParserEVENT, MySqlParserEVENTS, MySqlParserEVERY, MySqlParserEXCHANGE, MySqlParserEXCLUSIVE, MySqlParserEXPIRE, MySqlParserEXPORT, MySqlParserEXTENDED, MySqlParserEXTENT_SIZE, MySqlParserFAILED_LOGIN_ATTEMPTS, MySqlParserFAST, MySqlParserFAULTS, MySqlParserFIELDS, MySqlParserFILE_BLOCK_SIZE, MySqlParserFILTER, MySqlParserFIRST, MySqlParserFIXED, MySqlParserFLUSH, MySqlParserFOLLOWS, MySqlParserFOUND, MySqlParserFULL, MySqlParserFUNCTION, MySqlParserGENERAL, MySqlParserGLOBAL, MySqlParserGRANTS, MySqlParserGROUP_REPLICATION, MySqlParserHANDLER, MySqlParserHASH, MySqlParserHELP, MySqlParserHISTORY, MySqlParserHOST, MySqlParserHOSTS, MySqlParserIDENTIFIED, MySqlParserIGNORE_SERVER_IDS, MySqlParserIMPORT, MySqlParserINDEXES, MySqlParserINITIAL_SIZE, MySqlParserINPLACE, MySqlParserINSERT_METHOD, MySqlParserINSTALL, MySqlParserINSTANCE, MySqlParserINSTANT, MySqlParserINVISIBLE, MySqlParserINVOKER, MySqlParserIO, MySqlParserIO_THREAD, MySqlParserIPC, MySqlParserISOLATION, MySqlParserISSUER, MySqlParserJSON, MySqlParserKEY_BLOCK_SIZE, MySqlParserLANGUAGE, MySqlParserLAST, MySqlParserLEAVES, MySqlParserLESS, MySqlParserLEVEL, MySqlParserLIST, MySqlParserLOCAL, MySqlParserLOGFILE, MySqlParserLOGS, MySqlParserMASTER, MySqlParserMASTER_AUTO_POSITION, MySqlParserMASTER_CONNECT_RETRY, MySqlParserMASTER_DELAY, MySqlParserMASTER_HEARTBEAT_PERIOD, MySqlParserMASTER_HOST, MySqlParserMASTER_LOG_FILE, MySqlParserMASTER_LOG_POS, MySqlParserMASTER_PASSWORD, MySqlParserMASTER_PORT, MySqlParserMASTER_RETRY_COUNT, MySqlParserMASTER_SSL, MySqlParserMASTER_SSL_CA, MySqlParserMASTER_SSL_CAPATH, MySqlParserMASTER_SSL_CERT, MySqlParserMASTER_SSL_CIPHER, MySqlParserMASTER_SSL_CRL, MySqlParserMASTER_SSL_CRLPATH, MySqlParserMASTER_SSL_KEY, MySqlParserMASTER_TLS_VERSION, MySqlParserMASTER_USER, MySqlParserMAX_CONNECTIONS_PER_HOUR, MySqlParserMAX_QUERIES_PER_HOUR, MySqlParserMAX_ROWS, MySqlParserMAX_SIZE, MySqlParserMAX_UPDATES_PER_HOUR, MySqlParserMAX_USER_CONNECTIONS, MySqlParserMEDIUM, MySqlParserMEMBER, MySqlParserMERGE, MySqlParserMESSAGE_TEXT, MySqlParserMID, MySqlParserMIGRATE, MySqlParserMIN_ROWS, MySqlParserMODE, MySqlParserMODIFY, MySqlParserMUTEX, MySqlParserMYSQL, MySqlParserMYSQL_ERRNO, MySqlParserNAME, MySqlParserNAMES, MySqlParserNCHAR, MySqlParserNEVER, MySqlParserNEXT, MySqlParserNO, MySqlParserNOCOPY, MySqlParserNOWAIT, MySqlParserNODEGROUP, MySqlParserNONE, MySqlParserODBC, MySqlParserOFFLINE, MySqlParserOFFSET, MySqlParserOF, MySqlParserOJ, MySqlParserOLD_PASSWORD, MySqlParserONE, MySqlParserONLINE, MySqlParserONLY, MySqlParserOPEN, MySqlParserOPTIMIZER_COSTS, MySqlParserOPTIONS, MySqlParserOWNER, MySqlParserPACK_KEYS, MySqlParserPAGE, MySqlParserPARSER, MySqlParserPARTIAL, MySqlParserPARTITIONING, MySqlParserPARTITIONS, MySqlParserPASSWORD, MySqlParserPASSWORD_LOCK_TIME, MySqlParserPHASE, MySqlParserPLUGIN, MySqlParserPLUGIN_DIR, MySqlParserPLUGINS, MySqlParserPORT, MySqlParserPRECEDES, MySqlParserPREPARE, MySqlParserPRESERVE, MySqlParserPREV, MySqlParserPROCESSLIST, MySqlParserPROFILE, MySqlParserPROFILES, MySqlParserPROXY, MySqlParserQUERY, MySqlParserQUICK, MySqlParserREBUILD, MySqlParserRECOVER, MySqlParserRECURSIVE, MySqlParserREDO_BUFFER_SIZE, MySqlParserREDUNDANT, MySqlParserRELAY, MySqlParserRELAY_LOG_FILE, MySqlParserRELAY_LOG_POS, MySqlParserRELAYLOG, MySqlParserREMOVE, MySqlParserREORGANIZE, MySqlParserREPAIR, MySqlParserREPLICATE_DO_DB, MySqlParserREPLICATE_DO_TABLE, MySqlParserREPLICATE_IGNORE_DB, MySqlParserREPLICATE_IGNORE_TABLE, MySqlParserREPLICATE_REWRITE_DB, MySqlParserREPLICATE_WILD_DO_TABLE, MySqlParserREPLICATE_WILD_IGNORE_TABLE, MySqlParserREPLICATION, MySqlParserRESET, MySqlParserRESUME, MySqlParserRETURNED_SQLSTATE, MySqlParserRETURNING, MySqlParserRETURNS, MySqlParserREUSE, MySqlParserROLE, MySqlParserROLLBACK, MySqlParserROLLUP, MySqlParserROTATE, MySqlParserROW, MySqlParserROWS, MySqlParserROW_FORMAT, MySqlParserRTREE, MySqlParserSAVEPOINT, MySqlParserSCHEDULE, MySqlParserSECURITY, MySqlParserSERVER, MySqlParserSESSION, MySqlParserSHARE, MySqlParserSHARED, MySqlParserSIGNED, MySqlParserSIMPLE, MySqlParserSLAVE, MySqlParserSLOW, MySqlParserSNAPSHOT, MySqlParserSOCKET, MySqlParserSOME, MySqlParserSONAME, MySqlParserSOUNDS, MySqlParserSOURCE, MySqlParserSQL_AFTER_GTIDS, MySqlParserSQL_AFTER_MTS_GAPS, MySqlParserSQL_BEFORE_GTIDS, MySqlParserSQL_BUFFER_RESULT, MySqlParserSQL_CACHE, MySqlParserSQL_NO_CACHE, MySqlParserSQL_THREAD, MySqlParserSTART, MySqlParserSTARTS, MySqlParserSTATS_AUTO_RECALC, MySqlParserSTATS_PERSISTENT, MySqlParserSTATS_SAMPLE_PAGES, MySqlParserSTATUS, MySqlParserSTOP, MySqlParserSTORAGE, MySqlParserSTRING, MySqlParserSUBCLASS_ORIGIN, MySqlParserSUBJECT, MySqlParserSUBPARTITION, MySqlParserSUBPARTITIONS, MySqlParserSUSPEND, MySqlParserSWAPS, MySqlParserSWITCHES, MySqlParserTABLE_NAME, MySqlParserTABLESPACE, MySqlParserTABLE_TYPE, MySqlParserTEMPORARY, MySqlParserTEMPTABLE, MySqlParserTHAN, MySqlParserTRADITIONAL, MySqlParserTRANSACTION, MySqlParserTRANSACTIONAL, MySqlParserTRIGGERS, MySqlParserTRUNCATE, MySqlParserUNBOUNDED, MySqlParserUNDEFINED, MySqlParserUNDOFILE, MySqlParserUNDO_BUFFER_SIZE, MySqlParserUNINSTALL, MySqlParserUNKNOWN, MySqlParserUNTIL, MySqlParserUPGRADE, MySqlParserUSER, MySqlParserUSE_FRM, MySqlParserUSER_RESOURCES, MySqlParserVALIDATION, MySqlParserVALUE, MySqlParserVARIABLES, MySqlParserVIEW, MySqlParserVIRTUAL, MySqlParserVISIBLE, MySqlParserWAIT, MySqlParserWARNINGS, MySqlParserWITHOUT, MySqlParserWORK, MySqlParserWRAPPER, MySqlParserX509, MySqlParserXA, MySqlParserXML, MySqlParserYES, MySqlParserEUR, MySqlParserUSA, MySqlParserJIS, MySqlParserISO, MySqlParserINTERNAL, MySqlParserQUARTER, MySqlParserMONTH, MySqlParserDAY, MySqlParserHOUR, MySqlParserMINUTE, MySqlParserWEEK, MySqlParserSECOND, MySqlParserMICROSECOND, MySqlParserADMIN, MySqlParserAUDIT_ABORT_EXEMPT, MySqlParserAUDIT_ADMIN, MySqlParserAUTHENTICATION_POLICY_ADMIN, MySqlParserBACKUP_ADMIN, MySqlParserBINLOG_ADMIN, MySqlParserBINLOG_ENCRYPTION_ADMIN, MySqlParserCLONE_ADMIN, MySqlParserCONNECTION_ADMIN, MySqlParserENCRYPTION_KEY_ADMIN, MySqlParserEXECUTE, MySqlParserFILE, MySqlParserFIREWALL_ADMIN, MySqlParserFIREWALL_EXEMPT, MySqlParserFIREWALL_USER, MySqlParserGROUP_REPLICATION_ADMIN, MySqlParserINNODB_REDO_LOG_ARCHIVE, MySqlParserINVOKE, MySqlParserLAMBDA, MySqlParserNDB_STORED_USER, MySqlParserPASSWORDLESS_USER_ADMIN, MySqlParserPERSIST_RO_VARIABLES_ADMIN, MySqlParserPRIVILEGES, MySqlParserPROCESS, MySqlParserRELOAD, MySqlParserREPLICATION_APPLIER, MySqlParserREPLICATION_SLAVE_ADMIN, MySqlParserRESOURCE_GROUP_ADMIN, MySqlParserRESOURCE_GROUP_USER, MySqlParserROLE_ADMIN, MySqlParserROUTINE, MySqlParserS3, MySqlParserSESSION_VARIABLES_ADMIN, MySqlParserSET_USER_ID, MySqlParserSHOW_ROUTINE, MySqlParserSHUTDOWN, MySqlParserSUPER, MySqlParserSYSTEM_VARIABLES_ADMIN, MySqlParserTABLES, MySqlParserTABLE_ENCRYPTION_ADMIN, MySqlParserVERSION_TOKEN_ADMIN, MySqlParserXA_RECOVER_ADMIN, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserARCHIVE, MySqlParserBLACKHOLE, MySqlParserCSV, MySqlParserFEDERATED, MySqlParserINNODB, MySqlParserMEMORY, MySqlParserMRG_MYISAM, MySqlParserMYISAM, MySqlParserNDB, MySqlParserNDBCLUSTER, MySqlParserPERFORMANCE_SCHEMA, MySqlParserTOKUDB, MySqlParserREPEATABLE, MySqlParserCOMMITTED, MySqlParserUNCOMMITTED, MySqlParserSERIALIZABLE, MySqlParserGEOMETRYCOLLECTION, MySqlParserLINESTRING, MySqlParserMULTILINESTRING, MySqlParserMULTIPOINT, MySqlParserMULTIPOLYGON, MySqlParserPOINT, MySqlParserPOLYGON, MySqlParserABS, MySqlParserACOS, MySqlParserADDDATE, MySqlParserADDTIME, MySqlParserAES_DECRYPT, MySqlParserAES_ENCRYPT, MySqlParserAREA, MySqlParserASBINARY, MySqlParserASIN, MySqlParserASTEXT, MySqlParserASWKB, MySqlParserASWKT, MySqlParserASYMMETRIC_DECRYPT, MySqlParserASYMMETRIC_DERIVE, MySqlParserASYMMETRIC_ENCRYPT, MySqlParserASYMMETRIC_SIGN, MySqlParserASYMMETRIC_VERIFY, MySqlParserATAN, MySqlParserATAN2, MySqlParserBENCHMARK, MySqlParserBIN, MySqlParserBIT_COUNT, MySqlParserBIT_LENGTH, MySqlParserBUFFER, MySqlParserCATALOG_NAME, MySqlParserCEIL, MySqlParserCEILING, MySqlParserCENTROID, MySqlParserCHARACTER_LENGTH, MySqlParserCHARSET, MySqlParserCHAR_LENGTH, MySqlParserCOERCIBILITY, MySqlParserCOLLATION, MySqlParserCOMPRESS, MySqlParserCONCAT, MySqlParserCONCAT_WS, MySqlParserCONNECTION_ID, MySqlParserCONV, MySqlParserCONVERT_TZ, MySqlParserCOS, MySqlParserCOT, MySqlParserCRC32, MySqlParserCREATE_ASYMMETRIC_PRIV_KEY, MySqlParserCREATE_ASYMMETRIC_PUB_KEY, MySqlParserCREATE_DH_PARAMETERS, MySqlParserCREATE_DIGEST, MySqlParserCROSSES, MySqlParserDATEDIFF, MySqlParserDATE_FORMAT, MySqlParserDAYNAME, MySqlParserDAYOFMONTH, MySqlParserDAYOFWEEK, MySqlParserDAYOFYEAR, MySqlParserDECODE, MySqlParserDEGREES, MySqlParserDES_DECRYPT, MySqlParserDES_ENCRYPT, MySqlParserDIMENSION, MySqlParserDISJOINT, MySqlParserDISTANCE, MySqlParserELT, MySqlParserENCODE, MySqlParserENCRYPT, MySqlParserENDPOINT, MySqlParserENGINE_ATTRIBUTE, MySqlParserENVELOPE, MySqlParserEQUALS, MySqlParserEXP, MySqlParserEXPORT_SET, MySqlParserEXTERIORRING, MySqlParserEXTRACTVALUE, MySqlParserFIELD, MySqlParserFIND_IN_SET, MySqlParserFLOOR, MySqlParserFORMAT, MySqlParserFOUND_ROWS, MySqlParserFROM_BASE64, MySqlParserFROM_DAYS, MySqlParserFROM_UNIXTIME, MySqlParserGEOMCOLLFROMTEXT, MySqlParserGEOMCOLLFROMWKB, MySqlParserGEOMETRYCOLLECTIONFROMTEXT, MySqlParserGEOMETRYCOLLECTIONFROMWKB, MySqlParserGEOMETRYFROMTEXT, MySqlParserGEOMETRYFROMWKB, MySqlParserGEOMETRYN, MySqlParserGEOMETRYTYPE, MySqlParserGEOMFROMTEXT, MySqlParserGEOMFROMWKB, MySqlParserGET_FORMAT, MySqlParserGET_LOCK, MySqlParserGLENGTH, MySqlParserGREATEST, MySqlParserGTID_SUBSET, MySqlParserGTID_SUBTRACT, MySqlParserHEX, MySqlParserIFNULL, MySqlParserINET6_ATON, MySqlParserINET6_NTOA, MySqlParserINET_ATON, MySqlParserINET_NTOA, MySqlParserINSTR, MySqlParserINTERIORRINGN, MySqlParserINTERSECTS, MySqlParserISCLOSED, MySqlParserISEMPTY, MySqlParserISNULL, MySqlParserISSIMPLE, MySqlParserIS_FREE_LOCK, MySqlParserIS_IPV4, MySqlParserIS_IPV4_COMPAT, MySqlParserIS_IPV4_MAPPED, MySqlParserIS_IPV6, MySqlParserIS_USED_LOCK, MySqlParserLAST_INSERT_ID, MySqlParserLCASE, MySqlParserLEAST, MySqlParserLENGTH, MySqlParserLINEFROMTEXT, MySqlParserLINEFROMWKB, MySqlParserLINESTRINGFROMTEXT, MySqlParserLINESTRINGFROMWKB, MySqlParserLN, MySqlParserLOAD_FILE, MySqlParserLOCATE, MySqlParserLOG, MySqlParserLOG10, MySqlParserLOG2, MySqlParserLOWER, MySqlParserLPAD, MySqlParserLTRIM, MySqlParserMAKEDATE, MySqlParserMAKETIME, MySqlParserMAKE_SET, MySqlParserMASTER_POS_WAIT, MySqlParserMBRCONTAINS, MySqlParserMBRDISJOINT, MySqlParserMBREQUAL, MySqlParserMBRINTERSECTS, MySqlParserMBROVERLAPS, MySqlParserMBRTOUCHES, MySqlParserMBRWITHIN, MySqlParserMD5, MySqlParserMLINEFROMTEXT, MySqlParserMLINEFROMWKB, MySqlParserMONTHNAME, MySqlParserMPOINTFROMTEXT, MySqlParserMPOINTFROMWKB, MySqlParserMPOLYFROMTEXT, MySqlParserMPOLYFROMWKB, MySqlParserMULTILINESTRINGFROMTEXT, MySqlParserMULTILINESTRINGFROMWKB, MySqlParserMULTIPOINTFROMTEXT, MySqlParserMULTIPOINTFROMWKB, MySqlParserMULTIPOLYGONFROMTEXT, MySqlParserMULTIPOLYGONFROMWKB, MySqlParserNAME_CONST, MySqlParserNULLIF, MySqlParserNUMGEOMETRIES, MySqlParserNUMINTERIORRINGS, MySqlParserNUMPOINTS, MySqlParserOCT, MySqlParserOCTET_LENGTH, MySqlParserORD, MySqlParserOVERLAPS, MySqlParserPERIOD_ADD, MySqlParserPERIOD_DIFF, MySqlParserPI, MySqlParserPOINTFROMTEXT, MySqlParserPOINTFROMWKB, MySqlParserPOINTN, MySqlParserPOLYFROMTEXT, MySqlParserPOLYFROMWKB, MySqlParserPOLYGONFROMTEXT, MySqlParserPOLYGONFROMWKB, MySqlParserPOW, MySqlParserPOWER, MySqlParserQUOTE, MySqlParserRADIANS, MySqlParserRAND, MySqlParserRANDOM, MySqlParserRANDOM_BYTES, MySqlParserRELEASE_LOCK, MySqlParserREVERSE, MySqlParserROUND, MySqlParserROW_COUNT, MySqlParserRPAD, MySqlParserRTRIM, MySqlParserSEC_TO_TIME, MySqlParserSECONDARY_ENGINE_ATTRIBUTE, MySqlParserSESSION_USER, MySqlParserSHA, MySqlParserSHA1, MySqlParserSHA2, MySqlParserSCHEMA_NAME, MySqlParserSIGN, MySqlParserSIN, MySqlParserSLEEP, MySqlParserSOUNDEX, MySqlParserSQL_THREAD_WAIT_AFTER_GTIDS, MySqlParserSQRT, MySqlParserSRID, MySqlParserSTARTPOINT, MySqlParserSTRCMP, MySqlParserSTR_TO_DATE, MySqlParserST_AREA, MySqlParserST_ASBINARY, MySqlParserST_ASTEXT, MySqlParserST_ASWKB, MySqlParserST_ASWKT, MySqlParserST_BUFFER, MySqlParserST_CENTROID, MySqlParserST_CONTAINS, MySqlParserST_CROSSES, MySqlParserST_DIFFERENCE, MySqlParserST_DIMENSION, MySqlParserST_DISJOINT, MySqlParserST_DISTANCE, MySqlParserST_ENDPOINT, MySqlParserST_ENVELOPE, MySqlParserST_EQUALS, MySqlParserST_EXTERIORRING, MySqlParserST_GEOMCOLLFROMTEXT, MySqlParserST_GEOMCOLLFROMTXT, MySqlParserST_GEOMCOLLFROMWKB, MySqlParserST_GEOMETRYCOLLECTIONFROMTEXT, MySqlParserST_GEOMETRYCOLLECTIONFROMWKB, MySqlParserST_GEOMETRYFROMTEXT, MySqlParserST_GEOMETRYFROMWKB, MySqlParserST_GEOMETRYN, MySqlParserST_GEOMETRYTYPE, MySqlParserST_GEOMFROMTEXT, MySqlParserST_GEOMFROMWKB, MySqlParserST_INTERIORRINGN, MySqlParserST_INTERSECTION, MySqlParserST_INTERSECTS, MySqlParserST_ISCLOSED, MySqlParserST_ISEMPTY, MySqlParserST_ISSIMPLE, MySqlParserST_LINEFROMTEXT, MySqlParserST_LINEFROMWKB, MySqlParserST_LINESTRINGFROMTEXT, MySqlParserST_LINESTRINGFROMWKB, MySqlParserST_NUMGEOMETRIES, MySqlParserST_NUMINTERIORRING, MySqlParserST_NUMINTERIORRINGS, MySqlParserST_NUMPOINTS, MySqlParserST_OVERLAPS, MySqlParserST_POINTFROMTEXT, MySqlParserST_POINTFROMWKB, MySqlParserST_POINTN, MySqlParserST_POLYFROMTEXT, MySqlParserST_POLYFROMWKB, MySqlParserST_POLYGONFROMTEXT, MySqlParserST_POLYGONFROMWKB, MySqlParserST_SRID, MySqlParserST_STARTPOINT, MySqlParserST_SYMDIFFERENCE, MySqlParserST_TOUCHES, MySqlParserST_UNION, MySqlParserST_WITHIN, MySqlParserST_X, MySqlParserST_Y, MySqlParserSTRING_TO_VECTOR, MySqlParserSUBDATE, MySqlParserSUBSTRING_INDEX, MySqlParserSUBTIME, MySqlParserSYSTEM_USER, MySqlParserTAN, MySqlParserTIMEDIFF, MySqlParserTIMESTAMPADD, MySqlParserTIMESTAMPDIFF, MySqlParserTIME_FORMAT, MySqlParserTIME_TO_SEC, MySqlParserTOUCHES, MySqlParserTO_BASE64, MySqlParserTO_DAYS, MySqlParserTO_SECONDS, MySqlParserTP_CONNECTION_ADMIN, MySqlParserUCASE, MySqlParserUNCOMPRESS, MySqlParserUNCOMPRESSED_LENGTH, MySqlParserUNHEX, MySqlParserUNIX_TIMESTAMP, MySqlParserUPDATEXML, MySqlParserUPPER, MySqlParserUUID, MySqlParserUUID_SHORT, MySqlParserVALIDATE_PASSWORD_STRENGTH, MySqlParserVECTOR_DIM, MySqlParserVECTOR_TO_STRING, MySqlParserVERSION, MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS, MySqlParserWEEKDAY, MySqlParserWEEKOFYEAR, MySqlParserWEIGHT_STRING, MySqlParserWITHIN, MySqlParserYEARWEEK, MySqlParserY_FUNCTION, MySqlParserX_FUNCTION, MySqlParserMOD, MySqlParserID: + { + p.SetState(6220) + p.SimpleId() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWithStatementContext is an interface to support dynamic dispatch. +type IWithStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH() antlr.TerminalNode + AllCommonTableExpressions() []ICommonTableExpressionsContext + CommonTableExpressions(i int) ICommonTableExpressionsContext + RECURSIVE() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsWithStatementContext differentiates from other interfaces. + IsWithStatementContext() +} + +type WithStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWithStatementContext() *WithStatementContext { + var p = new(WithStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_withStatement + return p +} + +func InitEmptyWithStatementContext(p *WithStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_withStatement +} + +func (*WithStatementContext) IsWithStatementContext() {} + +func NewWithStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WithStatementContext { + var p = new(WithStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_withStatement + + return p +} + +func (s *WithStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *WithStatementContext) WITH() antlr.TerminalNode { + return s.GetToken(MySqlParserWITH, 0) +} + +func (s *WithStatementContext) AllCommonTableExpressions() []ICommonTableExpressionsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICommonTableExpressionsContext); ok { + len++ + } + } + + tst := make([]ICommonTableExpressionsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICommonTableExpressionsContext); ok { + tst[i] = t.(ICommonTableExpressionsContext) + i++ + } + } + + return tst +} + +func (s *WithStatementContext) CommonTableExpressions(i int) ICommonTableExpressionsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICommonTableExpressionsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICommonTableExpressionsContext) +} + +func (s *WithStatementContext) RECURSIVE() antlr.TerminalNode { + return s.GetToken(MySqlParserRECURSIVE, 0) +} + +func (s *WithStatementContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *WithStatementContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *WithStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *WithStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *WithStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterWithStatement(s) + } +} + +func (s *WithStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitWithStatement(s) + } +} + +func (p *MySqlParser) WithStatement() (localctx IWithStatementContext) { + localctx = NewWithStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 540, MySqlParserRULE_withStatement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6223) + p.Match(MySqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6225) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 913, p.GetParserRuleContext()) == 1 { + { + p.SetState(6224) + p.Match(MySqlParserRECURSIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6227) + p.CommonTableExpressions() + } + p.SetState(6232) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(6228) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6229) + p.CommonTableExpressions() + } + + p.SetState(6234) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITableStatementContext is an interface to support dynamic dispatch. +type ITableStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TABLE() antlr.TerminalNode + TableName() ITableNameContext + OrderByClause() IOrderByClauseContext + LimitClause() ILimitClauseContext + + // IsTableStatementContext differentiates from other interfaces. + IsTableStatementContext() +} + +type TableStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTableStatementContext() *TableStatementContext { + var p = new(TableStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_tableStatement + return p +} + +func InitEmptyTableStatementContext(p *TableStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_tableStatement +} + +func (*TableStatementContext) IsTableStatementContext() {} + +func NewTableStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableStatementContext { + var p = new(TableStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_tableStatement + + return p +} + +func (s *TableStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *TableStatementContext) TABLE() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLE, 0) +} + +func (s *TableStatementContext) TableName() ITableNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableNameContext) +} + +func (s *TableStatementContext) OrderByClause() IOrderByClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOrderByClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOrderByClauseContext) +} + +func (s *TableStatementContext) LimitClause() ILimitClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILimitClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILimitClauseContext) +} + +func (s *TableStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TableStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTableStatement(s) + } +} + +func (s *TableStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTableStatement(s) + } +} + +func (p *MySqlParser) TableStatement() (localctx ITableStatementContext) { + localctx = NewTableStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 542, MySqlParserRULE_tableStatement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6235) + p.Match(MySqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6236) + p.TableName() + } + p.SetState(6238) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserORDER { + { + p.SetState(6237) + p.OrderByClause() + } + + } + p.SetState(6241) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserLIMIT { + { + p.SetState(6240) + p.LimitClause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDiagnosticsStatementContext is an interface to support dynamic dispatch. +type IDiagnosticsStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GET() antlr.TerminalNode + DIAGNOSTICS() antlr.TerminalNode + CURRENT() antlr.TerminalNode + STACKED() antlr.TerminalNode + AllVariableClause() []IVariableClauseContext + VariableClause(i int) IVariableClauseContext + AllEQUAL_SYMBOL() []antlr.TerminalNode + EQUAL_SYMBOL(i int) antlr.TerminalNode + CONDITION() antlr.TerminalNode + AllDiagnosticsConditionInformationName() []IDiagnosticsConditionInformationNameContext + DiagnosticsConditionInformationName(i int) IDiagnosticsConditionInformationNameContext + AllNUMBER() []antlr.TerminalNode + NUMBER(i int) antlr.TerminalNode + AllROW_COUNT() []antlr.TerminalNode + ROW_COUNT(i int) antlr.TerminalNode + DecimalLiteral() IDecimalLiteralContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsDiagnosticsStatementContext differentiates from other interfaces. + IsDiagnosticsStatementContext() +} + +type DiagnosticsStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDiagnosticsStatementContext() *DiagnosticsStatementContext { + var p = new(DiagnosticsStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_diagnosticsStatement + return p +} + +func InitEmptyDiagnosticsStatementContext(p *DiagnosticsStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_diagnosticsStatement +} + +func (*DiagnosticsStatementContext) IsDiagnosticsStatementContext() {} + +func NewDiagnosticsStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DiagnosticsStatementContext { + var p = new(DiagnosticsStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_diagnosticsStatement + + return p +} + +func (s *DiagnosticsStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *DiagnosticsStatementContext) GET() antlr.TerminalNode { + return s.GetToken(MySqlParserGET, 0) +} + +func (s *DiagnosticsStatementContext) DIAGNOSTICS() antlr.TerminalNode { + return s.GetToken(MySqlParserDIAGNOSTICS, 0) +} + +func (s *DiagnosticsStatementContext) CURRENT() antlr.TerminalNode { + return s.GetToken(MySqlParserCURRENT, 0) +} + +func (s *DiagnosticsStatementContext) STACKED() antlr.TerminalNode { + return s.GetToken(MySqlParserSTACKED, 0) +} + +func (s *DiagnosticsStatementContext) AllVariableClause() []IVariableClauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IVariableClauseContext); ok { + len++ + } + } + + tst := make([]IVariableClauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IVariableClauseContext); ok { + tst[i] = t.(IVariableClauseContext) + i++ + } + } + + return tst +} + +func (s *DiagnosticsStatementContext) VariableClause(i int) IVariableClauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVariableClauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IVariableClauseContext) +} + +func (s *DiagnosticsStatementContext) AllEQUAL_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(MySqlParserEQUAL_SYMBOL) +} + +func (s *DiagnosticsStatementContext) EQUAL_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, i) +} + +func (s *DiagnosticsStatementContext) CONDITION() antlr.TerminalNode { + return s.GetToken(MySqlParserCONDITION, 0) +} + +func (s *DiagnosticsStatementContext) AllDiagnosticsConditionInformationName() []IDiagnosticsConditionInformationNameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDiagnosticsConditionInformationNameContext); ok { + len++ + } + } + + tst := make([]IDiagnosticsConditionInformationNameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDiagnosticsConditionInformationNameContext); ok { + tst[i] = t.(IDiagnosticsConditionInformationNameContext) + i++ + } + } + + return tst +} + +func (s *DiagnosticsStatementContext) DiagnosticsConditionInformationName(i int) IDiagnosticsConditionInformationNameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDiagnosticsConditionInformationNameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDiagnosticsConditionInformationNameContext) +} + +func (s *DiagnosticsStatementContext) AllNUMBER() []antlr.TerminalNode { + return s.GetTokens(MySqlParserNUMBER) +} + +func (s *DiagnosticsStatementContext) NUMBER(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserNUMBER, i) +} + +func (s *DiagnosticsStatementContext) AllROW_COUNT() []antlr.TerminalNode { + return s.GetTokens(MySqlParserROW_COUNT) +} + +func (s *DiagnosticsStatementContext) ROW_COUNT(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserROW_COUNT, i) +} + +func (s *DiagnosticsStatementContext) DecimalLiteral() IDecimalLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *DiagnosticsStatementContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *DiagnosticsStatementContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *DiagnosticsStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DiagnosticsStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DiagnosticsStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterDiagnosticsStatement(s) + } +} + +func (s *DiagnosticsStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitDiagnosticsStatement(s) + } +} + +func (p *MySqlParser) DiagnosticsStatement() (localctx IDiagnosticsStatementContext) { + localctx = NewDiagnosticsStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 544, MySqlParserRULE_diagnosticsStatement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6243) + p.Match(MySqlParserGET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6245) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserCURRENT || _la == MySqlParserSTACKED { + { + p.SetState(6244) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserCURRENT || _la == MySqlParserSTACKED) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(6247) + p.Match(MySqlParserDIAGNOSTICS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6279) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 921, p.GetParserRuleContext()) { + case 1: + { + p.SetState(6248) + p.VariableClause() + } + { + p.SetState(6249) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6250) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserNUMBER || _la == MySqlParserROW_COUNT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(6258) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(6251) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6252) + p.VariableClause() + } + { + p.SetState(6253) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6254) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserNUMBER || _la == MySqlParserROW_COUNT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + p.SetState(6260) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 2: + { + p.SetState(6261) + p.Match(MySqlParserCONDITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6264) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserZERO_DECIMAL, MySqlParserONE_DECIMAL, MySqlParserTWO_DECIMAL, MySqlParserDECIMAL_LITERAL, MySqlParserREAL_LITERAL: + { + p.SetState(6262) + p.DecimalLiteral() + } + + case MySqlParserARRAY, MySqlParserATTRIBUTE, MySqlParserBUCKETS, MySqlParserCONDITION, MySqlParserCURRENT, MySqlParserCURRENT_USER, MySqlParserDATABASE, MySqlParserDEFAULT, MySqlParserDIAGNOSTICS, MySqlParserEMPTY, MySqlParserENFORCED, MySqlParserEXCEPT, MySqlParserGROUP, MySqlParserIF, MySqlParserIGNORED, MySqlParserINSERT, MySqlParserLATERAL, MySqlParserLEFT, MySqlParserNUMBER, MySqlParserOPTIONAL, MySqlParserORDER, MySqlParserPRIMARY, MySqlParserREPEAT, MySqlParserREPLACE, MySqlParserRIGHT, MySqlParserSCHEMA, MySqlParserSKIP_QUERY_REWRITE, MySqlParserSTACKED, MySqlParserSTATEMENT, MySqlParserDATE, MySqlParserTIME, MySqlParserTIMESTAMP, MySqlParserDATETIME, MySqlParserYEAR, MySqlParserBINARY, MySqlParserTEXT, MySqlParserENUM, MySqlParserSERIAL, MySqlParserJSON_ARRAY, MySqlParserJSON_ARRAYAGG, MySqlParserJSON_ARRAY_APPEND, MySqlParserJSON_ARRAY_INSERT, MySqlParserJSON_CONTAINS, MySqlParserJSON_CONTAINS_PATH, MySqlParserJSON_DEPTH, MySqlParserJSON_EXTRACT, MySqlParserJSON_INSERT, MySqlParserJSON_KEYS, MySqlParserJSON_LENGTH, MySqlParserJSON_MERGE, MySqlParserJSON_MERGE_PATCH, MySqlParserJSON_MERGE_PRESERVE, MySqlParserJSON_OBJECT, MySqlParserJSON_OBJECTAGG, MySqlParserJSON_OVERLAPS, MySqlParserJSON_PRETTY, MySqlParserJSON_QUOTE, MySqlParserJSON_REMOVE, MySqlParserJSON_REPLACE, MySqlParserJSON_SCHEMA_VALID, MySqlParserJSON_SCHEMA_VALIDATION_REPORT, MySqlParserJSON_SEARCH, MySqlParserJSON_SET, MySqlParserJSON_STORAGE_FREE, MySqlParserJSON_STORAGE_SIZE, MySqlParserJSON_TABLE, MySqlParserJSON_TYPE, MySqlParserJSON_UNQUOTE, MySqlParserJSON_VALID, MySqlParserJSON_VALUE, MySqlParserNESTED, MySqlParserORDINALITY, MySqlParserPATH, MySqlParserAVG, MySqlParserBIT_AND, MySqlParserBIT_OR, MySqlParserBIT_XOR, MySqlParserCOUNT, MySqlParserCUME_DIST, MySqlParserDENSE_RANK, MySqlParserFIRST_VALUE, MySqlParserGROUP_CONCAT, MySqlParserLAG, MySqlParserLAST_VALUE, MySqlParserLEAD, MySqlParserMAX, MySqlParserMIN, MySqlParserNTILE, MySqlParserNTH_VALUE, MySqlParserPERCENT_RANK, MySqlParserRANK, MySqlParserROW_NUMBER, MySqlParserSTD, MySqlParserSTDDEV, MySqlParserSTDDEV_POP, MySqlParserSTDDEV_SAMP, MySqlParserSUM, MySqlParserVAR_POP, MySqlParserVAR_SAMP, MySqlParserVARIANCE, MySqlParserCURRENT_DATE, MySqlParserCURRENT_TIME, MySqlParserCURRENT_TIMESTAMP, MySqlParserLOCALTIME, MySqlParserCURDATE, MySqlParserCURTIME, MySqlParserDATE_ADD, MySqlParserDATE_SUB, MySqlParserLOCALTIMESTAMP, MySqlParserNOW, MySqlParserPOSITION, MySqlParserSUBSTR, MySqlParserSUBSTRING, MySqlParserSYSDATE, MySqlParserTRIM, MySqlParserUTC_DATE, MySqlParserUTC_TIME, MySqlParserUTC_TIMESTAMP, MySqlParserACCOUNT, MySqlParserACTION, MySqlParserAFTER, MySqlParserAGGREGATE, MySqlParserALGORITHM, MySqlParserANY, MySqlParserAT, MySqlParserAUTHORS, MySqlParserAUTOCOMMIT, MySqlParserAUTOEXTEND_SIZE, MySqlParserAUTO_INCREMENT, MySqlParserAVG_ROW_LENGTH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserBIT, MySqlParserBLOCK, MySqlParserBOOL, MySqlParserBOOLEAN, MySqlParserBTREE, MySqlParserCACHE, MySqlParserCASCADED, MySqlParserCHAIN, MySqlParserCHANGED, MySqlParserCHANNEL, MySqlParserCHECKSUM, MySqlParserPAGE_CHECKSUM, MySqlParserCIPHER, MySqlParserCLASS_ORIGIN, MySqlParserCLIENT, MySqlParserCLOSE, MySqlParserCLUSTERING, MySqlParserCOALESCE, MySqlParserCODE, MySqlParserCOLUMNS, MySqlParserCOLUMN_FORMAT, MySqlParserCOLUMN_NAME, MySqlParserCOMMENT, MySqlParserCOMMIT, MySqlParserCOMPACT, MySqlParserCOMPLETION, MySqlParserCOMPRESSED, MySqlParserCOMPRESSION, MySqlParserCONCURRENT, MySqlParserCONNECT, MySqlParserCONNECTION, MySqlParserCONSISTENT, MySqlParserCONSTRAINT_CATALOG, MySqlParserCONSTRAINT_SCHEMA, MySqlParserCONSTRAINT_NAME, MySqlParserCONTAINS, MySqlParserCONTEXT, MySqlParserCONTRIBUTORS, MySqlParserCOPY, MySqlParserCPU, MySqlParserCURSOR_NAME, MySqlParserDATA, MySqlParserDATAFILE, MySqlParserDEALLOCATE, MySqlParserDEFAULT_AUTH, MySqlParserDEFINER, MySqlParserDELAY_KEY_WRITE, MySqlParserDES_KEY_FILE, MySqlParserDIRECTORY, MySqlParserDISABLE, MySqlParserDISCARD, MySqlParserDISK, MySqlParserDO, MySqlParserDUMPFILE, MySqlParserDUPLICATE, MySqlParserDYNAMIC, MySqlParserENABLE, MySqlParserENCRYPTION, MySqlParserEND, MySqlParserENDS, MySqlParserENGINE, MySqlParserENGINES, MySqlParserERROR, MySqlParserERRORS, MySqlParserESCAPE, MySqlParserEVEN, MySqlParserEVENT, MySqlParserEVENTS, MySqlParserEVERY, MySqlParserEXCHANGE, MySqlParserEXCLUSIVE, MySqlParserEXPIRE, MySqlParserEXPORT, MySqlParserEXTENDED, MySqlParserEXTENT_SIZE, MySqlParserFAILED_LOGIN_ATTEMPTS, MySqlParserFAST, MySqlParserFAULTS, MySqlParserFIELDS, MySqlParserFILE_BLOCK_SIZE, MySqlParserFILTER, MySqlParserFIRST, MySqlParserFIXED, MySqlParserFLUSH, MySqlParserFOLLOWS, MySqlParserFOUND, MySqlParserFULL, MySqlParserFUNCTION, MySqlParserGENERAL, MySqlParserGLOBAL, MySqlParserGRANTS, MySqlParserGROUP_REPLICATION, MySqlParserHANDLER, MySqlParserHASH, MySqlParserHELP, MySqlParserHISTORY, MySqlParserHOST, MySqlParserHOSTS, MySqlParserIDENTIFIED, MySqlParserIGNORE_SERVER_IDS, MySqlParserIMPORT, MySqlParserINDEXES, MySqlParserINITIAL_SIZE, MySqlParserINPLACE, MySqlParserINSERT_METHOD, MySqlParserINSTALL, MySqlParserINSTANCE, MySqlParserINSTANT, MySqlParserINVISIBLE, MySqlParserINVOKER, MySqlParserIO, MySqlParserIO_THREAD, MySqlParserIPC, MySqlParserISOLATION, MySqlParserISSUER, MySqlParserJSON, MySqlParserKEY_BLOCK_SIZE, MySqlParserLANGUAGE, MySqlParserLAST, MySqlParserLEAVES, MySqlParserLESS, MySqlParserLEVEL, MySqlParserLIST, MySqlParserLOCAL, MySqlParserLOGFILE, MySqlParserLOGS, MySqlParserMASTER, MySqlParserMASTER_AUTO_POSITION, MySqlParserMASTER_CONNECT_RETRY, MySqlParserMASTER_DELAY, MySqlParserMASTER_HEARTBEAT_PERIOD, MySqlParserMASTER_HOST, MySqlParserMASTER_LOG_FILE, MySqlParserMASTER_LOG_POS, MySqlParserMASTER_PASSWORD, MySqlParserMASTER_PORT, MySqlParserMASTER_RETRY_COUNT, MySqlParserMASTER_SSL, MySqlParserMASTER_SSL_CA, MySqlParserMASTER_SSL_CAPATH, MySqlParserMASTER_SSL_CERT, MySqlParserMASTER_SSL_CIPHER, MySqlParserMASTER_SSL_CRL, MySqlParserMASTER_SSL_CRLPATH, MySqlParserMASTER_SSL_KEY, MySqlParserMASTER_TLS_VERSION, MySqlParserMASTER_USER, MySqlParserMAX_CONNECTIONS_PER_HOUR, MySqlParserMAX_QUERIES_PER_HOUR, MySqlParserMAX_ROWS, MySqlParserMAX_SIZE, MySqlParserMAX_UPDATES_PER_HOUR, MySqlParserMAX_USER_CONNECTIONS, MySqlParserMEDIUM, MySqlParserMEMBER, MySqlParserMERGE, MySqlParserMESSAGE_TEXT, MySqlParserMID, MySqlParserMIGRATE, MySqlParserMIN_ROWS, MySqlParserMODE, MySqlParserMODIFY, MySqlParserMUTEX, MySqlParserMYSQL, MySqlParserMYSQL_ERRNO, MySqlParserNAME, MySqlParserNAMES, MySqlParserNCHAR, MySqlParserNEVER, MySqlParserNEXT, MySqlParserNO, MySqlParserNOCOPY, MySqlParserNOWAIT, MySqlParserNODEGROUP, MySqlParserNONE, MySqlParserODBC, MySqlParserOFFLINE, MySqlParserOFFSET, MySqlParserOF, MySqlParserOJ, MySqlParserOLD_PASSWORD, MySqlParserONE, MySqlParserONLINE, MySqlParserONLY, MySqlParserOPEN, MySqlParserOPTIMIZER_COSTS, MySqlParserOPTIONS, MySqlParserOWNER, MySqlParserPACK_KEYS, MySqlParserPAGE, MySqlParserPARSER, MySqlParserPARTIAL, MySqlParserPARTITIONING, MySqlParserPARTITIONS, MySqlParserPASSWORD, MySqlParserPASSWORD_LOCK_TIME, MySqlParserPHASE, MySqlParserPLUGIN, MySqlParserPLUGIN_DIR, MySqlParserPLUGINS, MySqlParserPORT, MySqlParserPRECEDES, MySqlParserPREPARE, MySqlParserPRESERVE, MySqlParserPREV, MySqlParserPROCESSLIST, MySqlParserPROFILE, MySqlParserPROFILES, MySqlParserPROXY, MySqlParserQUERY, MySqlParserQUICK, MySqlParserREBUILD, MySqlParserRECOVER, MySqlParserRECURSIVE, MySqlParserREDO_BUFFER_SIZE, MySqlParserREDUNDANT, MySqlParserRELAY, MySqlParserRELAY_LOG_FILE, MySqlParserRELAY_LOG_POS, MySqlParserRELAYLOG, MySqlParserREMOVE, MySqlParserREORGANIZE, MySqlParserREPAIR, MySqlParserREPLICATE_DO_DB, MySqlParserREPLICATE_DO_TABLE, MySqlParserREPLICATE_IGNORE_DB, MySqlParserREPLICATE_IGNORE_TABLE, MySqlParserREPLICATE_REWRITE_DB, MySqlParserREPLICATE_WILD_DO_TABLE, MySqlParserREPLICATE_WILD_IGNORE_TABLE, MySqlParserREPLICATION, MySqlParserRESET, MySqlParserRESUME, MySqlParserRETURNED_SQLSTATE, MySqlParserRETURNING, MySqlParserRETURNS, MySqlParserREUSE, MySqlParserROLE, MySqlParserROLLBACK, MySqlParserROLLUP, MySqlParserROTATE, MySqlParserROW, MySqlParserROWS, MySqlParserROW_FORMAT, MySqlParserRTREE, MySqlParserSAVEPOINT, MySqlParserSCHEDULE, MySqlParserSECURITY, MySqlParserSERVER, MySqlParserSESSION, MySqlParserSHARE, MySqlParserSHARED, MySqlParserSIGNED, MySqlParserSIMPLE, MySqlParserSLAVE, MySqlParserSLOW, MySqlParserSNAPSHOT, MySqlParserSOCKET, MySqlParserSOME, MySqlParserSONAME, MySqlParserSOUNDS, MySqlParserSOURCE, MySqlParserSQL_AFTER_GTIDS, MySqlParserSQL_AFTER_MTS_GAPS, MySqlParserSQL_BEFORE_GTIDS, MySqlParserSQL_BUFFER_RESULT, MySqlParserSQL_CACHE, MySqlParserSQL_NO_CACHE, MySqlParserSQL_THREAD, MySqlParserSTART, MySqlParserSTARTS, MySqlParserSTATS_AUTO_RECALC, MySqlParserSTATS_PERSISTENT, MySqlParserSTATS_SAMPLE_PAGES, MySqlParserSTATUS, MySqlParserSTOP, MySqlParserSTORAGE, MySqlParserSTRING, MySqlParserSUBCLASS_ORIGIN, MySqlParserSUBJECT, MySqlParserSUBPARTITION, MySqlParserSUBPARTITIONS, MySqlParserSUSPEND, MySqlParserSWAPS, MySqlParserSWITCHES, MySqlParserTABLE_NAME, MySqlParserTABLESPACE, MySqlParserTABLE_TYPE, MySqlParserTEMPORARY, MySqlParserTEMPTABLE, MySqlParserTHAN, MySqlParserTRADITIONAL, MySqlParserTRANSACTION, MySqlParserTRANSACTIONAL, MySqlParserTRIGGERS, MySqlParserTRUNCATE, MySqlParserUNBOUNDED, MySqlParserUNDEFINED, MySqlParserUNDOFILE, MySqlParserUNDO_BUFFER_SIZE, MySqlParserUNINSTALL, MySqlParserUNKNOWN, MySqlParserUNTIL, MySqlParserUPGRADE, MySqlParserUSER, MySqlParserUSE_FRM, MySqlParserUSER_RESOURCES, MySqlParserVALIDATION, MySqlParserVALUE, MySqlParserVARIABLES, MySqlParserVIEW, MySqlParserVIRTUAL, MySqlParserVISIBLE, MySqlParserWAIT, MySqlParserWARNINGS, MySqlParserWITHOUT, MySqlParserWORK, MySqlParserWRAPPER, MySqlParserX509, MySqlParserXA, MySqlParserXML, MySqlParserYES, MySqlParserEUR, MySqlParserUSA, MySqlParserJIS, MySqlParserISO, MySqlParserINTERNAL, MySqlParserQUARTER, MySqlParserMONTH, MySqlParserDAY, MySqlParserHOUR, MySqlParserMINUTE, MySqlParserWEEK, MySqlParserSECOND, MySqlParserMICROSECOND, MySqlParserADMIN, MySqlParserAUDIT_ABORT_EXEMPT, MySqlParserAUDIT_ADMIN, MySqlParserAUTHENTICATION_POLICY_ADMIN, MySqlParserBACKUP_ADMIN, MySqlParserBINLOG_ADMIN, MySqlParserBINLOG_ENCRYPTION_ADMIN, MySqlParserCLONE_ADMIN, MySqlParserCONNECTION_ADMIN, MySqlParserENCRYPTION_KEY_ADMIN, MySqlParserEXECUTE, MySqlParserFILE, MySqlParserFIREWALL_ADMIN, MySqlParserFIREWALL_EXEMPT, MySqlParserFIREWALL_USER, MySqlParserGROUP_REPLICATION_ADMIN, MySqlParserINNODB_REDO_LOG_ARCHIVE, MySqlParserINVOKE, MySqlParserLAMBDA, MySqlParserNDB_STORED_USER, MySqlParserPASSWORDLESS_USER_ADMIN, MySqlParserPERSIST_RO_VARIABLES_ADMIN, MySqlParserPRIVILEGES, MySqlParserPROCESS, MySqlParserRELOAD, MySqlParserREPLICATION_APPLIER, MySqlParserREPLICATION_SLAVE_ADMIN, MySqlParserRESOURCE_GROUP_ADMIN, MySqlParserRESOURCE_GROUP_USER, MySqlParserROLE_ADMIN, MySqlParserROUTINE, MySqlParserS3, MySqlParserSESSION_VARIABLES_ADMIN, MySqlParserSET_USER_ID, MySqlParserSHOW_ROUTINE, MySqlParserSHUTDOWN, MySqlParserSUPER, MySqlParserSYSTEM_VARIABLES_ADMIN, MySqlParserTABLES, MySqlParserTABLE_ENCRYPTION_ADMIN, MySqlParserVERSION_TOKEN_ADMIN, MySqlParserXA_RECOVER_ADMIN, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserARCHIVE, MySqlParserBLACKHOLE, MySqlParserCSV, MySqlParserFEDERATED, MySqlParserINNODB, MySqlParserMEMORY, MySqlParserMRG_MYISAM, MySqlParserMYISAM, MySqlParserNDB, MySqlParserNDBCLUSTER, MySqlParserPERFORMANCE_SCHEMA, MySqlParserTOKUDB, MySqlParserREPEATABLE, MySqlParserCOMMITTED, MySqlParserUNCOMMITTED, MySqlParserSERIALIZABLE, MySqlParserGEOMETRYCOLLECTION, MySqlParserLINESTRING, MySqlParserMULTILINESTRING, MySqlParserMULTIPOINT, MySqlParserMULTIPOLYGON, MySqlParserPOINT, MySqlParserPOLYGON, MySqlParserABS, MySqlParserACOS, MySqlParserADDDATE, MySqlParserADDTIME, MySqlParserAES_DECRYPT, MySqlParserAES_ENCRYPT, MySqlParserAREA, MySqlParserASBINARY, MySqlParserASIN, MySqlParserASTEXT, MySqlParserASWKB, MySqlParserASWKT, MySqlParserASYMMETRIC_DECRYPT, MySqlParserASYMMETRIC_DERIVE, MySqlParserASYMMETRIC_ENCRYPT, MySqlParserASYMMETRIC_SIGN, MySqlParserASYMMETRIC_VERIFY, MySqlParserATAN, MySqlParserATAN2, MySqlParserBENCHMARK, MySqlParserBIN, MySqlParserBIT_COUNT, MySqlParserBIT_LENGTH, MySqlParserBUFFER, MySqlParserCATALOG_NAME, MySqlParserCEIL, MySqlParserCEILING, MySqlParserCENTROID, MySqlParserCHARACTER_LENGTH, MySqlParserCHARSET, MySqlParserCHAR_LENGTH, MySqlParserCOERCIBILITY, MySqlParserCOLLATION, MySqlParserCOMPRESS, MySqlParserCONCAT, MySqlParserCONCAT_WS, MySqlParserCONNECTION_ID, MySqlParserCONV, MySqlParserCONVERT_TZ, MySqlParserCOS, MySqlParserCOT, MySqlParserCRC32, MySqlParserCREATE_ASYMMETRIC_PRIV_KEY, MySqlParserCREATE_ASYMMETRIC_PUB_KEY, MySqlParserCREATE_DH_PARAMETERS, MySqlParserCREATE_DIGEST, MySqlParserCROSSES, MySqlParserDATEDIFF, MySqlParserDATE_FORMAT, MySqlParserDAYNAME, MySqlParserDAYOFMONTH, MySqlParserDAYOFWEEK, MySqlParserDAYOFYEAR, MySqlParserDECODE, MySqlParserDEGREES, MySqlParserDES_DECRYPT, MySqlParserDES_ENCRYPT, MySqlParserDIMENSION, MySqlParserDISJOINT, MySqlParserDISTANCE, MySqlParserELT, MySqlParserENCODE, MySqlParserENCRYPT, MySqlParserENDPOINT, MySqlParserENGINE_ATTRIBUTE, MySqlParserENVELOPE, MySqlParserEQUALS, MySqlParserEXP, MySqlParserEXPORT_SET, MySqlParserEXTERIORRING, MySqlParserEXTRACTVALUE, MySqlParserFIELD, MySqlParserFIND_IN_SET, MySqlParserFLOOR, MySqlParserFORMAT, MySqlParserFOUND_ROWS, MySqlParserFROM_BASE64, MySqlParserFROM_DAYS, MySqlParserFROM_UNIXTIME, MySqlParserGEOMCOLLFROMTEXT, MySqlParserGEOMCOLLFROMWKB, MySqlParserGEOMETRYCOLLECTIONFROMTEXT, MySqlParserGEOMETRYCOLLECTIONFROMWKB, MySqlParserGEOMETRYFROMTEXT, MySqlParserGEOMETRYFROMWKB, MySqlParserGEOMETRYN, MySqlParserGEOMETRYTYPE, MySqlParserGEOMFROMTEXT, MySqlParserGEOMFROMWKB, MySqlParserGET_FORMAT, MySqlParserGET_LOCK, MySqlParserGLENGTH, MySqlParserGREATEST, MySqlParserGTID_SUBSET, MySqlParserGTID_SUBTRACT, MySqlParserHEX, MySqlParserIFNULL, MySqlParserINET6_ATON, MySqlParserINET6_NTOA, MySqlParserINET_ATON, MySqlParserINET_NTOA, MySqlParserINSTR, MySqlParserINTERIORRINGN, MySqlParserINTERSECTS, MySqlParserISCLOSED, MySqlParserISEMPTY, MySqlParserISNULL, MySqlParserISSIMPLE, MySqlParserIS_FREE_LOCK, MySqlParserIS_IPV4, MySqlParserIS_IPV4_COMPAT, MySqlParserIS_IPV4_MAPPED, MySqlParserIS_IPV6, MySqlParserIS_USED_LOCK, MySqlParserLAST_INSERT_ID, MySqlParserLCASE, MySqlParserLEAST, MySqlParserLENGTH, MySqlParserLINEFROMTEXT, MySqlParserLINEFROMWKB, MySqlParserLINESTRINGFROMTEXT, MySqlParserLINESTRINGFROMWKB, MySqlParserLN, MySqlParserLOAD_FILE, MySqlParserLOCATE, MySqlParserLOG, MySqlParserLOG10, MySqlParserLOG2, MySqlParserLOWER, MySqlParserLPAD, MySqlParserLTRIM, MySqlParserMAKEDATE, MySqlParserMAKETIME, MySqlParserMAKE_SET, MySqlParserMASTER_POS_WAIT, MySqlParserMBRCONTAINS, MySqlParserMBRDISJOINT, MySqlParserMBREQUAL, MySqlParserMBRINTERSECTS, MySqlParserMBROVERLAPS, MySqlParserMBRTOUCHES, MySqlParserMBRWITHIN, MySqlParserMD5, MySqlParserMLINEFROMTEXT, MySqlParserMLINEFROMWKB, MySqlParserMONTHNAME, MySqlParserMPOINTFROMTEXT, MySqlParserMPOINTFROMWKB, MySqlParserMPOLYFROMTEXT, MySqlParserMPOLYFROMWKB, MySqlParserMULTILINESTRINGFROMTEXT, MySqlParserMULTILINESTRINGFROMWKB, MySqlParserMULTIPOINTFROMTEXT, MySqlParserMULTIPOINTFROMWKB, MySqlParserMULTIPOLYGONFROMTEXT, MySqlParserMULTIPOLYGONFROMWKB, MySqlParserNAME_CONST, MySqlParserNULLIF, MySqlParserNUMGEOMETRIES, MySqlParserNUMINTERIORRINGS, MySqlParserNUMPOINTS, MySqlParserOCT, MySqlParserOCTET_LENGTH, MySqlParserORD, MySqlParserOVERLAPS, MySqlParserPERIOD_ADD, MySqlParserPERIOD_DIFF, MySqlParserPI, MySqlParserPOINTFROMTEXT, MySqlParserPOINTFROMWKB, MySqlParserPOINTN, MySqlParserPOLYFROMTEXT, MySqlParserPOLYFROMWKB, MySqlParserPOLYGONFROMTEXT, MySqlParserPOLYGONFROMWKB, MySqlParserPOW, MySqlParserPOWER, MySqlParserQUOTE, MySqlParserRADIANS, MySqlParserRAND, MySqlParserRANDOM, MySqlParserRANDOM_BYTES, MySqlParserRELEASE_LOCK, MySqlParserREVERSE, MySqlParserROUND, MySqlParserROW_COUNT, MySqlParserRPAD, MySqlParserRTRIM, MySqlParserSEC_TO_TIME, MySqlParserSECONDARY_ENGINE_ATTRIBUTE, MySqlParserSESSION_USER, MySqlParserSHA, MySqlParserSHA1, MySqlParserSHA2, MySqlParserSCHEMA_NAME, MySqlParserSIGN, MySqlParserSIN, MySqlParserSLEEP, MySqlParserSOUNDEX, MySqlParserSQL_THREAD_WAIT_AFTER_GTIDS, MySqlParserSQRT, MySqlParserSRID, MySqlParserSTARTPOINT, MySqlParserSTRCMP, MySqlParserSTR_TO_DATE, MySqlParserST_AREA, MySqlParserST_ASBINARY, MySqlParserST_ASTEXT, MySqlParserST_ASWKB, MySqlParserST_ASWKT, MySqlParserST_BUFFER, MySqlParserST_CENTROID, MySqlParserST_CONTAINS, MySqlParserST_CROSSES, MySqlParserST_DIFFERENCE, MySqlParserST_DIMENSION, MySqlParserST_DISJOINT, MySqlParserST_DISTANCE, MySqlParserST_ENDPOINT, MySqlParserST_ENVELOPE, MySqlParserST_EQUALS, MySqlParserST_EXTERIORRING, MySqlParserST_GEOMCOLLFROMTEXT, MySqlParserST_GEOMCOLLFROMTXT, MySqlParserST_GEOMCOLLFROMWKB, MySqlParserST_GEOMETRYCOLLECTIONFROMTEXT, MySqlParserST_GEOMETRYCOLLECTIONFROMWKB, MySqlParserST_GEOMETRYFROMTEXT, MySqlParserST_GEOMETRYFROMWKB, MySqlParserST_GEOMETRYN, MySqlParserST_GEOMETRYTYPE, MySqlParserST_GEOMFROMTEXT, MySqlParserST_GEOMFROMWKB, MySqlParserST_INTERIORRINGN, MySqlParserST_INTERSECTION, MySqlParserST_INTERSECTS, MySqlParserST_ISCLOSED, MySqlParserST_ISEMPTY, MySqlParserST_ISSIMPLE, MySqlParserST_LINEFROMTEXT, MySqlParserST_LINEFROMWKB, MySqlParserST_LINESTRINGFROMTEXT, MySqlParserST_LINESTRINGFROMWKB, MySqlParserST_NUMGEOMETRIES, MySqlParserST_NUMINTERIORRING, MySqlParserST_NUMINTERIORRINGS, MySqlParserST_NUMPOINTS, MySqlParserST_OVERLAPS, MySqlParserST_POINTFROMTEXT, MySqlParserST_POINTFROMWKB, MySqlParserST_POINTN, MySqlParserST_POLYFROMTEXT, MySqlParserST_POLYFROMWKB, MySqlParserST_POLYGONFROMTEXT, MySqlParserST_POLYGONFROMWKB, MySqlParserST_SRID, MySqlParserST_STARTPOINT, MySqlParserST_SYMDIFFERENCE, MySqlParserST_TOUCHES, MySqlParserST_UNION, MySqlParserST_WITHIN, MySqlParserST_X, MySqlParserST_Y, MySqlParserSTRING_TO_VECTOR, MySqlParserSUBDATE, MySqlParserSUBSTRING_INDEX, MySqlParserSUBTIME, MySqlParserSYSTEM_USER, MySqlParserTAN, MySqlParserTIMEDIFF, MySqlParserTIMESTAMPADD, MySqlParserTIMESTAMPDIFF, MySqlParserTIME_FORMAT, MySqlParserTIME_TO_SEC, MySqlParserTOUCHES, MySqlParserTO_BASE64, MySqlParserTO_DAYS, MySqlParserTO_SECONDS, MySqlParserTP_CONNECTION_ADMIN, MySqlParserUCASE, MySqlParserUNCOMPRESS, MySqlParserUNCOMPRESSED_LENGTH, MySqlParserUNHEX, MySqlParserUNIX_TIMESTAMP, MySqlParserUPDATEXML, MySqlParserUPPER, MySqlParserUUID, MySqlParserUUID_SHORT, MySqlParserVALIDATE_PASSWORD_STRENGTH, MySqlParserVECTOR_DIM, MySqlParserVECTOR_TO_STRING, MySqlParserVERSION, MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS, MySqlParserWEEKDAY, MySqlParserWEEKOFYEAR, MySqlParserWEIGHT_STRING, MySqlParserWITHIN, MySqlParserYEARWEEK, MySqlParserY_FUNCTION, MySqlParserX_FUNCTION, MySqlParserMOD, MySqlParserAT_SIGN, MySqlParserCHARSET_REVERSE_QOUTE_STRING, MySqlParserSTRING_LITERAL, MySqlParserID, MySqlParserLOCAL_ID, MySqlParserGLOBAL_ID: + { + p.SetState(6263) + p.VariableClause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(6266) + p.VariableClause() + } + { + p.SetState(6267) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6268) + p.DiagnosticsConditionInformationName() + } + p.SetState(6276) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(6269) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6270) + p.VariableClause() + } + { + p.SetState(6271) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6272) + p.DiagnosticsConditionInformationName() + } + + p.SetState(6278) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDiagnosticsConditionInformationNameContext is an interface to support dynamic dispatch. +type IDiagnosticsConditionInformationNameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CLASS_ORIGIN() antlr.TerminalNode + SUBCLASS_ORIGIN() antlr.TerminalNode + RETURNED_SQLSTATE() antlr.TerminalNode + MESSAGE_TEXT() antlr.TerminalNode + MYSQL_ERRNO() antlr.TerminalNode + CONSTRAINT_CATALOG() antlr.TerminalNode + CONSTRAINT_SCHEMA() antlr.TerminalNode + CONSTRAINT_NAME() antlr.TerminalNode + CATALOG_NAME() antlr.TerminalNode + SCHEMA_NAME() antlr.TerminalNode + TABLE_NAME() antlr.TerminalNode + COLUMN_NAME() antlr.TerminalNode + CURSOR_NAME() antlr.TerminalNode + + // IsDiagnosticsConditionInformationNameContext differentiates from other interfaces. + IsDiagnosticsConditionInformationNameContext() +} + +type DiagnosticsConditionInformationNameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDiagnosticsConditionInformationNameContext() *DiagnosticsConditionInformationNameContext { + var p = new(DiagnosticsConditionInformationNameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_diagnosticsConditionInformationName + return p +} + +func InitEmptyDiagnosticsConditionInformationNameContext(p *DiagnosticsConditionInformationNameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_diagnosticsConditionInformationName +} + +func (*DiagnosticsConditionInformationNameContext) IsDiagnosticsConditionInformationNameContext() {} + +func NewDiagnosticsConditionInformationNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DiagnosticsConditionInformationNameContext { + var p = new(DiagnosticsConditionInformationNameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_diagnosticsConditionInformationName + + return p +} + +func (s *DiagnosticsConditionInformationNameContext) GetParser() antlr.Parser { return s.parser } + +func (s *DiagnosticsConditionInformationNameContext) CLASS_ORIGIN() antlr.TerminalNode { + return s.GetToken(MySqlParserCLASS_ORIGIN, 0) +} + +func (s *DiagnosticsConditionInformationNameContext) SUBCLASS_ORIGIN() antlr.TerminalNode { + return s.GetToken(MySqlParserSUBCLASS_ORIGIN, 0) +} + +func (s *DiagnosticsConditionInformationNameContext) RETURNED_SQLSTATE() antlr.TerminalNode { + return s.GetToken(MySqlParserRETURNED_SQLSTATE, 0) +} + +func (s *DiagnosticsConditionInformationNameContext) MESSAGE_TEXT() antlr.TerminalNode { + return s.GetToken(MySqlParserMESSAGE_TEXT, 0) +} + +func (s *DiagnosticsConditionInformationNameContext) MYSQL_ERRNO() antlr.TerminalNode { + return s.GetToken(MySqlParserMYSQL_ERRNO, 0) +} + +func (s *DiagnosticsConditionInformationNameContext) CONSTRAINT_CATALOG() antlr.TerminalNode { + return s.GetToken(MySqlParserCONSTRAINT_CATALOG, 0) +} + +func (s *DiagnosticsConditionInformationNameContext) CONSTRAINT_SCHEMA() antlr.TerminalNode { + return s.GetToken(MySqlParserCONSTRAINT_SCHEMA, 0) +} + +func (s *DiagnosticsConditionInformationNameContext) CONSTRAINT_NAME() antlr.TerminalNode { + return s.GetToken(MySqlParserCONSTRAINT_NAME, 0) +} + +func (s *DiagnosticsConditionInformationNameContext) CATALOG_NAME() antlr.TerminalNode { + return s.GetToken(MySqlParserCATALOG_NAME, 0) +} + +func (s *DiagnosticsConditionInformationNameContext) SCHEMA_NAME() antlr.TerminalNode { + return s.GetToken(MySqlParserSCHEMA_NAME, 0) +} + +func (s *DiagnosticsConditionInformationNameContext) TABLE_NAME() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLE_NAME, 0) +} + +func (s *DiagnosticsConditionInformationNameContext) COLUMN_NAME() antlr.TerminalNode { + return s.GetToken(MySqlParserCOLUMN_NAME, 0) +} + +func (s *DiagnosticsConditionInformationNameContext) CURSOR_NAME() antlr.TerminalNode { + return s.GetToken(MySqlParserCURSOR_NAME, 0) +} + +func (s *DiagnosticsConditionInformationNameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DiagnosticsConditionInformationNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DiagnosticsConditionInformationNameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterDiagnosticsConditionInformationName(s) + } +} + +func (s *DiagnosticsConditionInformationNameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitDiagnosticsConditionInformationName(s) + } +} + +func (p *MySqlParser) DiagnosticsConditionInformationName() (localctx IDiagnosticsConditionInformationNameContext) { + localctx = NewDiagnosticsConditionInformationNameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 546, MySqlParserRULE_diagnosticsConditionInformationName) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6281) + _la = p.GetTokenStream().LA(1) + + if !(((int64((_la-360)) & ^0x3f) == 0 && ((int64(1)<<(_la-360))&272105729) != 0) || _la == MySqlParserMESSAGE_TEXT || _la == MySqlParserMYSQL_ERRNO || ((int64((_la-593)) & ^0x3f) == 0 && ((int64(1)<<(_la-593))&18155135997837313) != 0) || _la == MySqlParserCATALOG_NAME || _la == MySqlParserSCHEMA_NAME) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDescribeObjectClauseContext is an interface to support dynamic dispatch. +type IDescribeObjectClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsDescribeObjectClauseContext differentiates from other interfaces. + IsDescribeObjectClauseContext() +} + +type DescribeObjectClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDescribeObjectClauseContext() *DescribeObjectClauseContext { + var p = new(DescribeObjectClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_describeObjectClause + return p +} + +func InitEmptyDescribeObjectClauseContext(p *DescribeObjectClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_describeObjectClause +} + +func (*DescribeObjectClauseContext) IsDescribeObjectClauseContext() {} + +func NewDescribeObjectClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DescribeObjectClauseContext { + var p = new(DescribeObjectClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_describeObjectClause + + return p +} + +func (s *DescribeObjectClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *DescribeObjectClauseContext) CopyAll(ctx *DescribeObjectClauseContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *DescribeObjectClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DescribeObjectClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type DescribeStatementsContext struct { + DescribeObjectClauseContext +} + +func NewDescribeStatementsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DescribeStatementsContext { + var p = new(DescribeStatementsContext) + + InitEmptyDescribeObjectClauseContext(&p.DescribeObjectClauseContext) + p.parser = parser + p.CopyAll(ctx.(*DescribeObjectClauseContext)) + + return p +} + +func (s *DescribeStatementsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DescribeStatementsContext) SelectStatement() ISelectStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelectStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelectStatementContext) +} + +func (s *DescribeStatementsContext) DeleteStatement() IDeleteStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeleteStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDeleteStatementContext) +} + +func (s *DescribeStatementsContext) InsertStatement() IInsertStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInsertStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInsertStatementContext) +} + +func (s *DescribeStatementsContext) ReplaceStatement() IReplaceStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReplaceStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReplaceStatementContext) +} + +func (s *DescribeStatementsContext) UpdateStatement() IUpdateStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdateStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUpdateStatementContext) +} + +func (s *DescribeStatementsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterDescribeStatements(s) + } +} + +func (s *DescribeStatementsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitDescribeStatements(s) + } +} + +type DescribeConnectionContext struct { + DescribeObjectClauseContext +} + +func NewDescribeConnectionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DescribeConnectionContext { + var p = new(DescribeConnectionContext) + + InitEmptyDescribeObjectClauseContext(&p.DescribeObjectClauseContext) + p.parser = parser + p.CopyAll(ctx.(*DescribeObjectClauseContext)) + + return p +} + +func (s *DescribeConnectionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DescribeConnectionContext) FOR() antlr.TerminalNode { + return s.GetToken(MySqlParserFOR, 0) +} + +func (s *DescribeConnectionContext) CONNECTION() antlr.TerminalNode { + return s.GetToken(MySqlParserCONNECTION, 0) +} + +func (s *DescribeConnectionContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *DescribeConnectionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterDescribeConnection(s) + } +} + +func (s *DescribeConnectionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitDescribeConnection(s) + } +} + +func (p *MySqlParser) DescribeObjectClause() (localctx IDescribeObjectClauseContext) { + localctx = NewDescribeObjectClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 548, MySqlParserRULE_describeObjectClause) + p.SetState(6293) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserDELETE, MySqlParserINSERT, MySqlParserREPLACE, MySqlParserSELECT, MySqlParserUPDATE, MySqlParserLR_BRACKET: + localctx = NewDescribeStatementsContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + p.SetState(6288) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserSELECT, MySqlParserLR_BRACKET: + { + p.SetState(6283) + p.SelectStatement() + } + + case MySqlParserDELETE: + { + p.SetState(6284) + p.DeleteStatement() + } + + case MySqlParserINSERT: + { + p.SetState(6285) + p.InsertStatement() + } + + case MySqlParserREPLACE: + { + p.SetState(6286) + p.ReplaceStatement() + } + + case MySqlParserUPDATE: + { + p.SetState(6287) + p.UpdateStatement() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case MySqlParserFOR: + localctx = NewDescribeConnectionContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6290) + p.Match(MySqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6291) + p.Match(MySqlParserCONNECTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6292) + p.Uid() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFullIdContext is an interface to support dynamic dispatch. +type IFullIdContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllUid() []IUidContext + Uid(i int) IUidContext + DOT_ID() antlr.TerminalNode + DOT() antlr.TerminalNode + + // IsFullIdContext differentiates from other interfaces. + IsFullIdContext() +} + +type FullIdContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFullIdContext() *FullIdContext { + var p = new(FullIdContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_fullId + return p +} + +func InitEmptyFullIdContext(p *FullIdContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_fullId +} + +func (*FullIdContext) IsFullIdContext() {} + +func NewFullIdContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FullIdContext { + var p = new(FullIdContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_fullId + + return p +} + +func (s *FullIdContext) GetParser() antlr.Parser { return s.parser } + +func (s *FullIdContext) AllUid() []IUidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUidContext); ok { + len++ + } + } + + tst := make([]IUidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUidContext); ok { + tst[i] = t.(IUidContext) + i++ + } + } + + return tst +} + +func (s *FullIdContext) Uid(i int) IUidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *FullIdContext) DOT_ID() antlr.TerminalNode { + return s.GetToken(MySqlParserDOT_ID, 0) +} + +func (s *FullIdContext) DOT() antlr.TerminalNode { + return s.GetToken(MySqlParserDOT, 0) +} + +func (s *FullIdContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FullIdContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FullIdContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterFullId(s) + } +} + +func (s *FullIdContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitFullId(s) + } +} + +func (p *MySqlParser) FullId() (localctx IFullIdContext) { + localctx = NewFullIdContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 550, MySqlParserRULE_fullId) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6295) + p.Uid() + } + p.SetState(6299) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 924, p.GetParserRuleContext()) == 1 { + { + p.SetState(6296) + p.Match(MySqlParserDOT_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 924, p.GetParserRuleContext()) == 2 { + { + p.SetState(6297) + p.Match(MySqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6298) + p.Uid() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITableNameContext is an interface to support dynamic dispatch. +type ITableNameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FullId() IFullIdContext + + // IsTableNameContext differentiates from other interfaces. + IsTableNameContext() +} + +type TableNameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTableNameContext() *TableNameContext { + var p = new(TableNameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_tableName + return p +} + +func InitEmptyTableNameContext(p *TableNameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_tableName +} + +func (*TableNameContext) IsTableNameContext() {} + +func NewTableNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableNameContext { + var p = new(TableNameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_tableName + + return p +} + +func (s *TableNameContext) GetParser() antlr.Parser { return s.parser } + +func (s *TableNameContext) FullId() IFullIdContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFullIdContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFullIdContext) +} + +func (s *TableNameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TableNameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTableName(s) + } +} + +func (s *TableNameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTableName(s) + } +} + +func (p *MySqlParser) TableName() (localctx ITableNameContext) { + localctx = NewTableNameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 552, MySqlParserRULE_tableName) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6301) + p.FullId() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRoleNameContext is an interface to support dynamic dispatch. +type IRoleNameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UserName() IUserNameContext + Uid() IUidContext + + // IsRoleNameContext differentiates from other interfaces. + IsRoleNameContext() +} + +type RoleNameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRoleNameContext() *RoleNameContext { + var p = new(RoleNameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_roleName + return p +} + +func InitEmptyRoleNameContext(p *RoleNameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_roleName +} + +func (*RoleNameContext) IsRoleNameContext() {} + +func NewRoleNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RoleNameContext { + var p = new(RoleNameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_roleName + + return p +} + +func (s *RoleNameContext) GetParser() antlr.Parser { return s.parser } + +func (s *RoleNameContext) UserName() IUserNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUserNameContext) +} + +func (s *RoleNameContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *RoleNameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RoleNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RoleNameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterRoleName(s) + } +} + +func (s *RoleNameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitRoleName(s) + } +} + +func (p *MySqlParser) RoleName() (localctx IRoleNameContext) { + localctx = NewRoleNameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 554, MySqlParserRULE_roleName) + p.SetState(6305) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 925, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6303) + p.UserName() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6304) + p.Uid() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFullColumnNameContext is an interface to support dynamic dispatch. +type IFullColumnNameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Uid() IUidContext + AllDottedId() []IDottedIdContext + DottedId(i int) IDottedIdContext + + // IsFullColumnNameContext differentiates from other interfaces. + IsFullColumnNameContext() +} + +type FullColumnNameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFullColumnNameContext() *FullColumnNameContext { + var p = new(FullColumnNameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_fullColumnName + return p +} + +func InitEmptyFullColumnNameContext(p *FullColumnNameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_fullColumnName +} + +func (*FullColumnNameContext) IsFullColumnNameContext() {} + +func NewFullColumnNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FullColumnNameContext { + var p = new(FullColumnNameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_fullColumnName + + return p +} + +func (s *FullColumnNameContext) GetParser() antlr.Parser { return s.parser } + +func (s *FullColumnNameContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *FullColumnNameContext) AllDottedId() []IDottedIdContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDottedIdContext); ok { + len++ + } + } + + tst := make([]IDottedIdContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDottedIdContext); ok { + tst[i] = t.(IDottedIdContext) + i++ + } + } + + return tst +} + +func (s *FullColumnNameContext) DottedId(i int) IDottedIdContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDottedIdContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDottedIdContext) +} + +func (s *FullColumnNameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FullColumnNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FullColumnNameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterFullColumnName(s) + } +} + +func (s *FullColumnNameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitFullColumnName(s) + } +} + +func (p *MySqlParser) FullColumnName() (localctx IFullColumnNameContext) { + localctx = NewFullColumnNameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 556, MySqlParserRULE_fullColumnName) + p.SetState(6321) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 930, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6307) + p.Uid() + } + p.SetState(6312) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 927, p.GetParserRuleContext()) == 1 { + { + p.SetState(6308) + p.DottedId() + } + p.SetState(6310) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 926, p.GetParserRuleContext()) == 1 { + { + p.SetState(6309) + p.DottedId() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + p.SetState(6315) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 928, p.GetParserRuleContext()) == 1 { + p.SetState(6314) + p.MatchWildcard() + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6317) + p.DottedId() + } + p.SetState(6319) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 929, p.GetParserRuleContext()) == 1 { + { + p.SetState(6318) + p.DottedId() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndexColumnNameContext is an interface to support dynamic dispatch. +type IIndexColumnNameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetSortType returns the sortType token. + GetSortType() antlr.Token + + // SetSortType sets the sortType token. + SetSortType(antlr.Token) + + // Getter signatures + Expression() IExpressionContext + Uid() IUidContext + STRING_LITERAL() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + DecimalLiteral() IDecimalLiteralContext + RR_BRACKET() antlr.TerminalNode + ASC() antlr.TerminalNode + DESC() antlr.TerminalNode + + // IsIndexColumnNameContext differentiates from other interfaces. + IsIndexColumnNameContext() +} + +type IndexColumnNameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + sortType antlr.Token +} + +func NewEmptyIndexColumnNameContext() *IndexColumnNameContext { + var p = new(IndexColumnNameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_indexColumnName + return p +} + +func InitEmptyIndexColumnNameContext(p *IndexColumnNameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_indexColumnName +} + +func (*IndexColumnNameContext) IsIndexColumnNameContext() {} + +func NewIndexColumnNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndexColumnNameContext { + var p = new(IndexColumnNameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_indexColumnName + + return p +} + +func (s *IndexColumnNameContext) GetParser() antlr.Parser { return s.parser } + +func (s *IndexColumnNameContext) GetSortType() antlr.Token { return s.sortType } + +func (s *IndexColumnNameContext) SetSortType(v antlr.Token) { s.sortType = v } + +func (s *IndexColumnNameContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *IndexColumnNameContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *IndexColumnNameContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *IndexColumnNameContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *IndexColumnNameContext) DecimalLiteral() IDecimalLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *IndexColumnNameContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *IndexColumnNameContext) ASC() antlr.TerminalNode { + return s.GetToken(MySqlParserASC, 0) +} + +func (s *IndexColumnNameContext) DESC() antlr.TerminalNode { + return s.GetToken(MySqlParserDESC, 0) +} + +func (s *IndexColumnNameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IndexColumnNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IndexColumnNameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterIndexColumnName(s) + } +} + +func (s *IndexColumnNameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitIndexColumnName(s) + } +} + +func (p *MySqlParser) IndexColumnName() (localctx IIndexColumnNameContext) { + localctx = NewIndexColumnNameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 558, MySqlParserRULE_indexColumnName) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(6334) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 933, p.GetParserRuleContext()) { + case 1: + p.SetState(6325) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 931, p.GetParserRuleContext()) { + case 1: + { + p.SetState(6323) + p.Uid() + } + + case 2: + { + p.SetState(6324) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(6331) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserLR_BRACKET { + { + p.SetState(6327) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6328) + p.DecimalLiteral() + } + { + p.SetState(6329) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 2: + { + p.SetState(6333) + p.expression(0) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(6337) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserASC || _la == MySqlParserDESC { + { + p.SetState(6336) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*IndexColumnNameContext).sortType = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserASC || _la == MySqlParserDESC) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*IndexColumnNameContext).sortType = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISimpleUserNameContext is an interface to support dynamic dispatch. +type ISimpleUserNameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + STRING_LITERAL() antlr.TerminalNode + ID() antlr.TerminalNode + ADMIN() antlr.TerminalNode + KeywordsCanBeId() IKeywordsCanBeIdContext + + // IsSimpleUserNameContext differentiates from other interfaces. + IsSimpleUserNameContext() +} + +type SimpleUserNameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySimpleUserNameContext() *SimpleUserNameContext { + var p = new(SimpleUserNameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_simpleUserName + return p +} + +func InitEmptySimpleUserNameContext(p *SimpleUserNameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_simpleUserName +} + +func (*SimpleUserNameContext) IsSimpleUserNameContext() {} + +func NewSimpleUserNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SimpleUserNameContext { + var p = new(SimpleUserNameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_simpleUserName + + return p +} + +func (s *SimpleUserNameContext) GetParser() antlr.Parser { return s.parser } + +func (s *SimpleUserNameContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *SimpleUserNameContext) ID() antlr.TerminalNode { + return s.GetToken(MySqlParserID, 0) +} + +func (s *SimpleUserNameContext) ADMIN() antlr.TerminalNode { + return s.GetToken(MySqlParserADMIN, 0) +} + +func (s *SimpleUserNameContext) KeywordsCanBeId() IKeywordsCanBeIdContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeywordsCanBeIdContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeywordsCanBeIdContext) +} + +func (s *SimpleUserNameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SimpleUserNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SimpleUserNameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSimpleUserName(s) + } +} + +func (s *SimpleUserNameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSimpleUserName(s) + } +} + +func (p *MySqlParser) SimpleUserName() (localctx ISimpleUserNameContext) { + localctx = NewSimpleUserNameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 560, MySqlParserRULE_simpleUserName) + p.SetState(6343) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 935, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6339) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6340) + p.Match(MySqlParserID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6341) + p.Match(MySqlParserADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(6342) + p.KeywordsCanBeId() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHostNameContext is an interface to support dynamic dispatch. +type IHostNameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LOCAL_ID() antlr.TerminalNode + HOST_IP_ADDRESS() antlr.TerminalNode + AT_SIGN() antlr.TerminalNode + + // IsHostNameContext differentiates from other interfaces. + IsHostNameContext() +} + +type HostNameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHostNameContext() *HostNameContext { + var p = new(HostNameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_hostName + return p +} + +func InitEmptyHostNameContext(p *HostNameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_hostName +} + +func (*HostNameContext) IsHostNameContext() {} + +func NewHostNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *HostNameContext { + var p = new(HostNameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_hostName + + return p +} + +func (s *HostNameContext) GetParser() antlr.Parser { return s.parser } + +func (s *HostNameContext) LOCAL_ID() antlr.TerminalNode { + return s.GetToken(MySqlParserLOCAL_ID, 0) +} + +func (s *HostNameContext) HOST_IP_ADDRESS() antlr.TerminalNode { + return s.GetToken(MySqlParserHOST_IP_ADDRESS, 0) +} + +func (s *HostNameContext) AT_SIGN() antlr.TerminalNode { + return s.GetToken(MySqlParserAT_SIGN, 0) +} + +func (s *HostNameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *HostNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *HostNameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterHostName(s) + } +} + +func (s *HostNameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitHostName(s) + } +} + +func (p *MySqlParser) HostName() (localctx IHostNameContext) { + localctx = NewHostNameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 562, MySqlParserRULE_hostName) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6345) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-1142)) & ^0x3f) == 0 && ((int64(1)<<(_la-1142))&6291457) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUserNameContext is an interface to support dynamic dispatch. +type IUserNameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SimpleUserName() ISimpleUserNameContext + HostName() IHostNameContext + CurrentUserExpression() ICurrentUserExpressionContext + + // IsUserNameContext differentiates from other interfaces. + IsUserNameContext() +} + +type UserNameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUserNameContext() *UserNameContext { + var p = new(UserNameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_userName + return p +} + +func InitEmptyUserNameContext(p *UserNameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_userName +} + +func (*UserNameContext) IsUserNameContext() {} + +func NewUserNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UserNameContext { + var p = new(UserNameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_userName + + return p +} + +func (s *UserNameContext) GetParser() antlr.Parser { return s.parser } + +func (s *UserNameContext) SimpleUserName() ISimpleUserNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimpleUserNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISimpleUserNameContext) +} + +func (s *UserNameContext) HostName() IHostNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHostNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHostNameContext) +} + +func (s *UserNameContext) CurrentUserExpression() ICurrentUserExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICurrentUserExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICurrentUserExpressionContext) +} + +func (s *UserNameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UserNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *UserNameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterUserName(s) + } +} + +func (s *UserNameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitUserName(s) + } +} + +func (p *MySqlParser) UserName() (localctx IUserNameContext) { + localctx = NewUserNameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 564, MySqlParserRULE_userName) + p.SetState(6352) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 936, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6347) + p.SimpleUserName() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6348) + p.SimpleUserName() + } + { + p.SetState(6349) + p.HostName() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6351) + p.CurrentUserExpression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMysqlVariableContext is an interface to support dynamic dispatch. +type IMysqlVariableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LOCAL_ID() antlr.TerminalNode + GLOBAL_ID() antlr.TerminalNode + + // IsMysqlVariableContext differentiates from other interfaces. + IsMysqlVariableContext() +} + +type MysqlVariableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMysqlVariableContext() *MysqlVariableContext { + var p = new(MysqlVariableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_mysqlVariable + return p +} + +func InitEmptyMysqlVariableContext(p *MysqlVariableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_mysqlVariable +} + +func (*MysqlVariableContext) IsMysqlVariableContext() {} + +func NewMysqlVariableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MysqlVariableContext { + var p = new(MysqlVariableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_mysqlVariable + + return p +} + +func (s *MysqlVariableContext) GetParser() antlr.Parser { return s.parser } + +func (s *MysqlVariableContext) LOCAL_ID() antlr.TerminalNode { + return s.GetToken(MySqlParserLOCAL_ID, 0) +} + +func (s *MysqlVariableContext) GLOBAL_ID() antlr.TerminalNode { + return s.GetToken(MySqlParserGLOBAL_ID, 0) +} + +func (s *MysqlVariableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MysqlVariableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *MysqlVariableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterMysqlVariable(s) + } +} + +func (s *MysqlVariableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitMysqlVariable(s) + } +} + +func (p *MySqlParser) MysqlVariable() (localctx IMysqlVariableContext) { + localctx = NewMysqlVariableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 566, MySqlParserRULE_mysqlVariable) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6354) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserLOCAL_ID || _la == MySqlParserGLOBAL_ID) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICharsetNameContext is an interface to support dynamic dispatch. +type ICharsetNameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BINARY() antlr.TerminalNode + CharsetNameBase() ICharsetNameBaseContext + STRING_LITERAL() antlr.TerminalNode + CHARSET_REVERSE_QOUTE_STRING() antlr.TerminalNode + + // IsCharsetNameContext differentiates from other interfaces. + IsCharsetNameContext() +} + +type CharsetNameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCharsetNameContext() *CharsetNameContext { + var p = new(CharsetNameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_charsetName + return p +} + +func InitEmptyCharsetNameContext(p *CharsetNameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_charsetName +} + +func (*CharsetNameContext) IsCharsetNameContext() {} + +func NewCharsetNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CharsetNameContext { + var p = new(CharsetNameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_charsetName + + return p +} + +func (s *CharsetNameContext) GetParser() antlr.Parser { return s.parser } + +func (s *CharsetNameContext) BINARY() antlr.TerminalNode { + return s.GetToken(MySqlParserBINARY, 0) +} + +func (s *CharsetNameContext) CharsetNameBase() ICharsetNameBaseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICharsetNameBaseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICharsetNameBaseContext) +} + +func (s *CharsetNameContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *CharsetNameContext) CHARSET_REVERSE_QOUTE_STRING() antlr.TerminalNode { + return s.GetToken(MySqlParserCHARSET_REVERSE_QOUTE_STRING, 0) +} + +func (s *CharsetNameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CharsetNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CharsetNameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCharsetName(s) + } +} + +func (s *CharsetNameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCharsetName(s) + } +} + +func (p *MySqlParser) CharsetName() (localctx ICharsetNameContext) { + localctx = NewCharsetNameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 568, MySqlParserRULE_charsetName) + p.SetState(6360) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 937, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6356) + p.Match(MySqlParserBINARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6357) + p.CharsetNameBase() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6358) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(6359) + p.Match(MySqlParserCHARSET_REVERSE_QOUTE_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICollationNameContext is an interface to support dynamic dispatch. +type ICollationNameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Uid() IUidContext + STRING_LITERAL() antlr.TerminalNode + + // IsCollationNameContext differentiates from other interfaces. + IsCollationNameContext() +} + +type CollationNameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCollationNameContext() *CollationNameContext { + var p = new(CollationNameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_collationName + return p +} + +func InitEmptyCollationNameContext(p *CollationNameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_collationName +} + +func (*CollationNameContext) IsCollationNameContext() {} + +func NewCollationNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollationNameContext { + var p = new(CollationNameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_collationName + + return p +} + +func (s *CollationNameContext) GetParser() antlr.Parser { return s.parser } + +func (s *CollationNameContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *CollationNameContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *CollationNameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CollationNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CollationNameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCollationName(s) + } +} + +func (s *CollationNameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCollationName(s) + } +} + +func (p *MySqlParser) CollationName() (localctx ICollationNameContext) { + localctx = NewCollationNameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 570, MySqlParserRULE_collationName) + p.SetState(6364) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 938, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6362) + p.Uid() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6363) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IEngineNameContext is an interface to support dynamic dispatch. +type IEngineNameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EngineNameBase() IEngineNameBaseContext + ID() antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + + // IsEngineNameContext differentiates from other interfaces. + IsEngineNameContext() +} + +type EngineNameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEngineNameContext() *EngineNameContext { + var p = new(EngineNameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_engineName + return p +} + +func InitEmptyEngineNameContext(p *EngineNameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_engineName +} + +func (*EngineNameContext) IsEngineNameContext() {} + +func NewEngineNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EngineNameContext { + var p = new(EngineNameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_engineName + + return p +} + +func (s *EngineNameContext) GetParser() antlr.Parser { return s.parser } + +func (s *EngineNameContext) EngineNameBase() IEngineNameBaseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEngineNameBaseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEngineNameBaseContext) +} + +func (s *EngineNameContext) ID() antlr.TerminalNode { + return s.GetToken(MySqlParserID, 0) +} + +func (s *EngineNameContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *EngineNameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *EngineNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *EngineNameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterEngineName(s) + } +} + +func (s *EngineNameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitEngineName(s) + } +} + +func (p *MySqlParser) EngineName() (localctx IEngineNameContext) { + localctx = NewEngineNameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 572, MySqlParserRULE_engineName) + p.SetState(6369) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserCONNECT, MySqlParserARCHIVE, MySqlParserBLACKHOLE, MySqlParserCSV, MySqlParserFEDERATED, MySqlParserINNODB, MySqlParserMEMORY, MySqlParserMRG_MYISAM, MySqlParserMYISAM, MySqlParserNDB, MySqlParserNDBCLUSTER, MySqlParserPERFORMANCE_SCHEMA, MySqlParserTOKUDB: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6366) + p.EngineNameBase() + } + + case MySqlParserID: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6367) + p.Match(MySqlParserID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserSTRING_LITERAL: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6368) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IEngineNameBaseContext is an interface to support dynamic dispatch. +type IEngineNameBaseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ARCHIVE() antlr.TerminalNode + BLACKHOLE() antlr.TerminalNode + CONNECT() antlr.TerminalNode + CSV() antlr.TerminalNode + FEDERATED() antlr.TerminalNode + INNODB() antlr.TerminalNode + MEMORY() antlr.TerminalNode + MRG_MYISAM() antlr.TerminalNode + MYISAM() antlr.TerminalNode + NDB() antlr.TerminalNode + NDBCLUSTER() antlr.TerminalNode + PERFORMANCE_SCHEMA() antlr.TerminalNode + TOKUDB() antlr.TerminalNode + + // IsEngineNameBaseContext differentiates from other interfaces. + IsEngineNameBaseContext() +} + +type EngineNameBaseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEngineNameBaseContext() *EngineNameBaseContext { + var p = new(EngineNameBaseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_engineNameBase + return p +} + +func InitEmptyEngineNameBaseContext(p *EngineNameBaseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_engineNameBase +} + +func (*EngineNameBaseContext) IsEngineNameBaseContext() {} + +func NewEngineNameBaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EngineNameBaseContext { + var p = new(EngineNameBaseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_engineNameBase + + return p +} + +func (s *EngineNameBaseContext) GetParser() antlr.Parser { return s.parser } + +func (s *EngineNameBaseContext) ARCHIVE() antlr.TerminalNode { + return s.GetToken(MySqlParserARCHIVE, 0) +} + +func (s *EngineNameBaseContext) BLACKHOLE() antlr.TerminalNode { + return s.GetToken(MySqlParserBLACKHOLE, 0) +} + +func (s *EngineNameBaseContext) CONNECT() antlr.TerminalNode { + return s.GetToken(MySqlParserCONNECT, 0) +} + +func (s *EngineNameBaseContext) CSV() antlr.TerminalNode { + return s.GetToken(MySqlParserCSV, 0) +} + +func (s *EngineNameBaseContext) FEDERATED() antlr.TerminalNode { + return s.GetToken(MySqlParserFEDERATED, 0) +} + +func (s *EngineNameBaseContext) INNODB() antlr.TerminalNode { + return s.GetToken(MySqlParserINNODB, 0) +} + +func (s *EngineNameBaseContext) MEMORY() antlr.TerminalNode { + return s.GetToken(MySqlParserMEMORY, 0) +} + +func (s *EngineNameBaseContext) MRG_MYISAM() antlr.TerminalNode { + return s.GetToken(MySqlParserMRG_MYISAM, 0) +} + +func (s *EngineNameBaseContext) MYISAM() antlr.TerminalNode { + return s.GetToken(MySqlParserMYISAM, 0) +} + +func (s *EngineNameBaseContext) NDB() antlr.TerminalNode { + return s.GetToken(MySqlParserNDB, 0) +} + +func (s *EngineNameBaseContext) NDBCLUSTER() antlr.TerminalNode { + return s.GetToken(MySqlParserNDBCLUSTER, 0) +} + +func (s *EngineNameBaseContext) PERFORMANCE_SCHEMA() antlr.TerminalNode { + return s.GetToken(MySqlParserPERFORMANCE_SCHEMA, 0) +} + +func (s *EngineNameBaseContext) TOKUDB() antlr.TerminalNode { + return s.GetToken(MySqlParserTOKUDB, 0) +} + +func (s *EngineNameBaseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *EngineNameBaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *EngineNameBaseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterEngineNameBase(s) + } +} + +func (s *EngineNameBaseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitEngineNameBase(s) + } +} + +func (p *MySqlParser) EngineNameBase() (localctx IEngineNameBaseContext) { + localctx = NewEngineNameBaseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 574, MySqlParserRULE_engineNameBase) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6371) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserCONNECT || ((int64((_la-788)) & ^0x3f) == 0 && ((int64(1)<<(_la-788))&4095) != 0)) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUuidSetContext is an interface to support dynamic dispatch. +type IUuidSetContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllDecimalLiteral() []IDecimalLiteralContext + DecimalLiteral(i int) IDecimalLiteralContext + AllMINUS() []antlr.TerminalNode + MINUS(i int) antlr.TerminalNode + AllCOLON_SYMB() []antlr.TerminalNode + COLON_SYMB(i int) antlr.TerminalNode + + // IsUuidSetContext differentiates from other interfaces. + IsUuidSetContext() +} + +type UuidSetContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUuidSetContext() *UuidSetContext { + var p = new(UuidSetContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_uuidSet + return p +} + +func InitEmptyUuidSetContext(p *UuidSetContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_uuidSet +} + +func (*UuidSetContext) IsUuidSetContext() {} + +func NewUuidSetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UuidSetContext { + var p = new(UuidSetContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_uuidSet + + return p +} + +func (s *UuidSetContext) GetParser() antlr.Parser { return s.parser } + +func (s *UuidSetContext) AllDecimalLiteral() []IDecimalLiteralContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDecimalLiteralContext); ok { + len++ + } + } + + tst := make([]IDecimalLiteralContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDecimalLiteralContext); ok { + tst[i] = t.(IDecimalLiteralContext) + i++ + } + } + + return tst +} + +func (s *UuidSetContext) DecimalLiteral(i int) IDecimalLiteralContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *UuidSetContext) AllMINUS() []antlr.TerminalNode { + return s.GetTokens(MySqlParserMINUS) +} + +func (s *UuidSetContext) MINUS(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserMINUS, i) +} + +func (s *UuidSetContext) AllCOLON_SYMB() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOLON_SYMB) +} + +func (s *UuidSetContext) COLON_SYMB(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOLON_SYMB, i) +} + +func (s *UuidSetContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UuidSetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *UuidSetContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterUuidSet(s) + } +} + +func (s *UuidSetContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitUuidSet(s) + } +} + +func (p *MySqlParser) UuidSet() (localctx IUuidSetContext) { + localctx = NewUuidSetContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 576, MySqlParserRULE_uuidSet) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6373) + p.DecimalLiteral() + } + { + p.SetState(6374) + p.Match(MySqlParserMINUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6375) + p.DecimalLiteral() + } + { + p.SetState(6376) + p.Match(MySqlParserMINUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6377) + p.DecimalLiteral() + } + { + p.SetState(6378) + p.Match(MySqlParserMINUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6379) + p.DecimalLiteral() + } + { + p.SetState(6380) + p.Match(MySqlParserMINUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6381) + p.DecimalLiteral() + } + p.SetState(6387) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == MySqlParserCOLON_SYMB { + { + p.SetState(6382) + p.Match(MySqlParserCOLON_SYMB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6383) + p.DecimalLiteral() + } + { + p.SetState(6384) + p.Match(MySqlParserMINUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6385) + p.DecimalLiteral() + } + + p.SetState(6389) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXidContext is an interface to support dynamic dispatch. +type IXidContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetGlobalTableUid returns the globalTableUid rule contexts. + GetGlobalTableUid() IXuidStringIdContext + + // GetQualifier returns the qualifier rule contexts. + GetQualifier() IXuidStringIdContext + + // GetIdFormat returns the idFormat rule contexts. + GetIdFormat() IDecimalLiteralContext + + // SetGlobalTableUid sets the globalTableUid rule contexts. + SetGlobalTableUid(IXuidStringIdContext) + + // SetQualifier sets the qualifier rule contexts. + SetQualifier(IXuidStringIdContext) + + // SetIdFormat sets the idFormat rule contexts. + SetIdFormat(IDecimalLiteralContext) + + // Getter signatures + AllXuidStringId() []IXuidStringIdContext + XuidStringId(i int) IXuidStringIdContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + DecimalLiteral() IDecimalLiteralContext + + // IsXidContext differentiates from other interfaces. + IsXidContext() +} + +type XidContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + globalTableUid IXuidStringIdContext + qualifier IXuidStringIdContext + idFormat IDecimalLiteralContext +} + +func NewEmptyXidContext() *XidContext { + var p = new(XidContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_xid + return p +} + +func InitEmptyXidContext(p *XidContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_xid +} + +func (*XidContext) IsXidContext() {} + +func NewXidContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *XidContext { + var p = new(XidContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_xid + + return p +} + +func (s *XidContext) GetParser() antlr.Parser { return s.parser } + +func (s *XidContext) GetGlobalTableUid() IXuidStringIdContext { return s.globalTableUid } + +func (s *XidContext) GetQualifier() IXuidStringIdContext { return s.qualifier } + +func (s *XidContext) GetIdFormat() IDecimalLiteralContext { return s.idFormat } + +func (s *XidContext) SetGlobalTableUid(v IXuidStringIdContext) { s.globalTableUid = v } + +func (s *XidContext) SetQualifier(v IXuidStringIdContext) { s.qualifier = v } + +func (s *XidContext) SetIdFormat(v IDecimalLiteralContext) { s.idFormat = v } + +func (s *XidContext) AllXuidStringId() []IXuidStringIdContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IXuidStringIdContext); ok { + len++ + } + } + + tst := make([]IXuidStringIdContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IXuidStringIdContext); ok { + tst[i] = t.(IXuidStringIdContext) + i++ + } + } + + return tst +} + +func (s *XidContext) XuidStringId(i int) IXuidStringIdContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXuidStringIdContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IXuidStringIdContext) +} + +func (s *XidContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *XidContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *XidContext) DecimalLiteral() IDecimalLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *XidContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *XidContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *XidContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterXid(s) + } +} + +func (s *XidContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitXid(s) + } +} + +func (p *MySqlParser) Xid() (localctx IXidContext) { + localctx = NewXidContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 578, MySqlParserRULE_xid) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6391) + + var _x = p.XuidStringId() + + localctx.(*XidContext).globalTableUid = _x + } + p.SetState(6398) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserCOMMA { + { + p.SetState(6392) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6393) + + var _x = p.XuidStringId() + + localctx.(*XidContext).qualifier = _x + } + p.SetState(6396) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserCOMMA { + { + p.SetState(6394) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6395) + + var _x = p.DecimalLiteral() + + localctx.(*XidContext).idFormat = _x + } + + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXuidStringIdContext is an interface to support dynamic dispatch. +type IXuidStringIdContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + STRING_LITERAL() antlr.TerminalNode + BIT_STRING() antlr.TerminalNode + AllHEXADECIMAL_LITERAL() []antlr.TerminalNode + HEXADECIMAL_LITERAL(i int) antlr.TerminalNode + + // IsXuidStringIdContext differentiates from other interfaces. + IsXuidStringIdContext() +} + +type XuidStringIdContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXuidStringIdContext() *XuidStringIdContext { + var p = new(XuidStringIdContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_xuidStringId + return p +} + +func InitEmptyXuidStringIdContext(p *XuidStringIdContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_xuidStringId +} + +func (*XuidStringIdContext) IsXuidStringIdContext() {} + +func NewXuidStringIdContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *XuidStringIdContext { + var p = new(XuidStringIdContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_xuidStringId + + return p +} + +func (s *XuidStringIdContext) GetParser() antlr.Parser { return s.parser } + +func (s *XuidStringIdContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *XuidStringIdContext) BIT_STRING() antlr.TerminalNode { + return s.GetToken(MySqlParserBIT_STRING, 0) +} + +func (s *XuidStringIdContext) AllHEXADECIMAL_LITERAL() []antlr.TerminalNode { + return s.GetTokens(MySqlParserHEXADECIMAL_LITERAL) +} + +func (s *XuidStringIdContext) HEXADECIMAL_LITERAL(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserHEXADECIMAL_LITERAL, i) +} + +func (s *XuidStringIdContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *XuidStringIdContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *XuidStringIdContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterXuidStringId(s) + } +} + +func (s *XuidStringIdContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitXuidStringId(s) + } +} + +func (p *MySqlParser) XuidStringId() (localctx IXuidStringIdContext) { + localctx = NewXuidStringIdContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 580, MySqlParserRULE_xuidStringId) + var _la int + + p.SetState(6407) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserSTRING_LITERAL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6400) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserBIT_STRING: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6401) + p.Match(MySqlParserBIT_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserHEXADECIMAL_LITERAL: + p.EnterOuterAlt(localctx, 3) + p.SetState(6403) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == MySqlParserHEXADECIMAL_LITERAL { + { + p.SetState(6402) + p.Match(MySqlParserHEXADECIMAL_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(6405) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAuthPluginContext is an interface to support dynamic dispatch. +type IAuthPluginContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Uid() IUidContext + STRING_LITERAL() antlr.TerminalNode + + // IsAuthPluginContext differentiates from other interfaces. + IsAuthPluginContext() +} + +type AuthPluginContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAuthPluginContext() *AuthPluginContext { + var p = new(AuthPluginContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_authPlugin + return p +} + +func InitEmptyAuthPluginContext(p *AuthPluginContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_authPlugin +} + +func (*AuthPluginContext) IsAuthPluginContext() {} + +func NewAuthPluginContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AuthPluginContext { + var p = new(AuthPluginContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_authPlugin + + return p +} + +func (s *AuthPluginContext) GetParser() antlr.Parser { return s.parser } + +func (s *AuthPluginContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *AuthPluginContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *AuthPluginContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AuthPluginContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AuthPluginContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAuthPlugin(s) + } +} + +func (s *AuthPluginContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAuthPlugin(s) + } +} + +func (p *MySqlParser) AuthPlugin() (localctx IAuthPluginContext) { + localctx = NewAuthPluginContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 582, MySqlParserRULE_authPlugin) + p.SetState(6411) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 945, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6409) + p.Uid() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6410) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUidContext is an interface to support dynamic dispatch. +type IUidContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SimpleId() ISimpleIdContext + CHARSET_REVERSE_QOUTE_STRING() antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + + // IsUidContext differentiates from other interfaces. + IsUidContext() +} + +type UidContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUidContext() *UidContext { + var p = new(UidContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_uid + return p +} + +func InitEmptyUidContext(p *UidContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_uid +} + +func (*UidContext) IsUidContext() {} + +func NewUidContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UidContext { + var p = new(UidContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_uid + + return p +} + +func (s *UidContext) GetParser() antlr.Parser { return s.parser } + +func (s *UidContext) SimpleId() ISimpleIdContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimpleIdContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISimpleIdContext) +} + +func (s *UidContext) CHARSET_REVERSE_QOUTE_STRING() antlr.TerminalNode { + return s.GetToken(MySqlParserCHARSET_REVERSE_QOUTE_STRING, 0) +} + +func (s *UidContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *UidContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UidContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *UidContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterUid(s) + } +} + +func (s *UidContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitUid(s) + } +} + +func (p *MySqlParser) Uid() (localctx IUidContext) { + localctx = NewUidContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 584, MySqlParserRULE_uid) + p.SetState(6416) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserARRAY, MySqlParserATTRIBUTE, MySqlParserBUCKETS, MySqlParserCONDITION, MySqlParserCURRENT, MySqlParserCURRENT_USER, MySqlParserDATABASE, MySqlParserDEFAULT, MySqlParserDIAGNOSTICS, MySqlParserEMPTY, MySqlParserENFORCED, MySqlParserEXCEPT, MySqlParserGROUP, MySqlParserIF, MySqlParserIGNORED, MySqlParserINSERT, MySqlParserLATERAL, MySqlParserLEFT, MySqlParserNUMBER, MySqlParserOPTIONAL, MySqlParserORDER, MySqlParserPRIMARY, MySqlParserREPEAT, MySqlParserREPLACE, MySqlParserRIGHT, MySqlParserSCHEMA, MySqlParserSKIP_QUERY_REWRITE, MySqlParserSTACKED, MySqlParserSTATEMENT, MySqlParserDATE, MySqlParserTIME, MySqlParserTIMESTAMP, MySqlParserDATETIME, MySqlParserYEAR, MySqlParserBINARY, MySqlParserTEXT, MySqlParserENUM, MySqlParserSERIAL, MySqlParserJSON_ARRAY, MySqlParserJSON_ARRAYAGG, MySqlParserJSON_ARRAY_APPEND, MySqlParserJSON_ARRAY_INSERT, MySqlParserJSON_CONTAINS, MySqlParserJSON_CONTAINS_PATH, MySqlParserJSON_DEPTH, MySqlParserJSON_EXTRACT, MySqlParserJSON_INSERT, MySqlParserJSON_KEYS, MySqlParserJSON_LENGTH, MySqlParserJSON_MERGE, MySqlParserJSON_MERGE_PATCH, MySqlParserJSON_MERGE_PRESERVE, MySqlParserJSON_OBJECT, MySqlParserJSON_OBJECTAGG, MySqlParserJSON_OVERLAPS, MySqlParserJSON_PRETTY, MySqlParserJSON_QUOTE, MySqlParserJSON_REMOVE, MySqlParserJSON_REPLACE, MySqlParserJSON_SCHEMA_VALID, MySqlParserJSON_SCHEMA_VALIDATION_REPORT, MySqlParserJSON_SEARCH, MySqlParserJSON_SET, MySqlParserJSON_STORAGE_FREE, MySqlParserJSON_STORAGE_SIZE, MySqlParserJSON_TABLE, MySqlParserJSON_TYPE, MySqlParserJSON_UNQUOTE, MySqlParserJSON_VALID, MySqlParserJSON_VALUE, MySqlParserNESTED, MySqlParserORDINALITY, MySqlParserPATH, MySqlParserAVG, MySqlParserBIT_AND, MySqlParserBIT_OR, MySqlParserBIT_XOR, MySqlParserCOUNT, MySqlParserCUME_DIST, MySqlParserDENSE_RANK, MySqlParserFIRST_VALUE, MySqlParserGROUP_CONCAT, MySqlParserLAG, MySqlParserLAST_VALUE, MySqlParserLEAD, MySqlParserMAX, MySqlParserMIN, MySqlParserNTILE, MySqlParserNTH_VALUE, MySqlParserPERCENT_RANK, MySqlParserRANK, MySqlParserROW_NUMBER, MySqlParserSTD, MySqlParserSTDDEV, MySqlParserSTDDEV_POP, MySqlParserSTDDEV_SAMP, MySqlParserSUM, MySqlParserVAR_POP, MySqlParserVAR_SAMP, MySqlParserVARIANCE, MySqlParserCURRENT_DATE, MySqlParserCURRENT_TIME, MySqlParserCURRENT_TIMESTAMP, MySqlParserLOCALTIME, MySqlParserCURDATE, MySqlParserCURTIME, MySqlParserDATE_ADD, MySqlParserDATE_SUB, MySqlParserLOCALTIMESTAMP, MySqlParserNOW, MySqlParserPOSITION, MySqlParserSUBSTR, MySqlParserSUBSTRING, MySqlParserSYSDATE, MySqlParserTRIM, MySqlParserUTC_DATE, MySqlParserUTC_TIME, MySqlParserUTC_TIMESTAMP, MySqlParserACCOUNT, MySqlParserACTION, MySqlParserAFTER, MySqlParserAGGREGATE, MySqlParserALGORITHM, MySqlParserANY, MySqlParserAT, MySqlParserAUTHORS, MySqlParserAUTOCOMMIT, MySqlParserAUTOEXTEND_SIZE, MySqlParserAUTO_INCREMENT, MySqlParserAVG_ROW_LENGTH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserBIT, MySqlParserBLOCK, MySqlParserBOOL, MySqlParserBOOLEAN, MySqlParserBTREE, MySqlParserCACHE, MySqlParserCASCADED, MySqlParserCHAIN, MySqlParserCHANGED, MySqlParserCHANNEL, MySqlParserCHECKSUM, MySqlParserPAGE_CHECKSUM, MySqlParserCIPHER, MySqlParserCLASS_ORIGIN, MySqlParserCLIENT, MySqlParserCLOSE, MySqlParserCLUSTERING, MySqlParserCOALESCE, MySqlParserCODE, MySqlParserCOLUMNS, MySqlParserCOLUMN_FORMAT, MySqlParserCOLUMN_NAME, MySqlParserCOMMENT, MySqlParserCOMMIT, MySqlParserCOMPACT, MySqlParserCOMPLETION, MySqlParserCOMPRESSED, MySqlParserCOMPRESSION, MySqlParserCONCURRENT, MySqlParserCONNECT, MySqlParserCONNECTION, MySqlParserCONSISTENT, MySqlParserCONSTRAINT_CATALOG, MySqlParserCONSTRAINT_SCHEMA, MySqlParserCONSTRAINT_NAME, MySqlParserCONTAINS, MySqlParserCONTEXT, MySqlParserCONTRIBUTORS, MySqlParserCOPY, MySqlParserCPU, MySqlParserCURSOR_NAME, MySqlParserDATA, MySqlParserDATAFILE, MySqlParserDEALLOCATE, MySqlParserDEFAULT_AUTH, MySqlParserDEFINER, MySqlParserDELAY_KEY_WRITE, MySqlParserDES_KEY_FILE, MySqlParserDIRECTORY, MySqlParserDISABLE, MySqlParserDISCARD, MySqlParserDISK, MySqlParserDO, MySqlParserDUMPFILE, MySqlParserDUPLICATE, MySqlParserDYNAMIC, MySqlParserENABLE, MySqlParserENCRYPTION, MySqlParserEND, MySqlParserENDS, MySqlParserENGINE, MySqlParserENGINES, MySqlParserERROR, MySqlParserERRORS, MySqlParserESCAPE, MySqlParserEVEN, MySqlParserEVENT, MySqlParserEVENTS, MySqlParserEVERY, MySqlParserEXCHANGE, MySqlParserEXCLUSIVE, MySqlParserEXPIRE, MySqlParserEXPORT, MySqlParserEXTENDED, MySqlParserEXTENT_SIZE, MySqlParserFAILED_LOGIN_ATTEMPTS, MySqlParserFAST, MySqlParserFAULTS, MySqlParserFIELDS, MySqlParserFILE_BLOCK_SIZE, MySqlParserFILTER, MySqlParserFIRST, MySqlParserFIXED, MySqlParserFLUSH, MySqlParserFOLLOWS, MySqlParserFOUND, MySqlParserFULL, MySqlParserFUNCTION, MySqlParserGENERAL, MySqlParserGLOBAL, MySqlParserGRANTS, MySqlParserGROUP_REPLICATION, MySqlParserHANDLER, MySqlParserHASH, MySqlParserHELP, MySqlParserHISTORY, MySqlParserHOST, MySqlParserHOSTS, MySqlParserIDENTIFIED, MySqlParserIGNORE_SERVER_IDS, MySqlParserIMPORT, MySqlParserINDEXES, MySqlParserINITIAL_SIZE, MySqlParserINPLACE, MySqlParserINSERT_METHOD, MySqlParserINSTALL, MySqlParserINSTANCE, MySqlParserINSTANT, MySqlParserINVISIBLE, MySqlParserINVOKER, MySqlParserIO, MySqlParserIO_THREAD, MySqlParserIPC, MySqlParserISOLATION, MySqlParserISSUER, MySqlParserJSON, MySqlParserKEY_BLOCK_SIZE, MySqlParserLANGUAGE, MySqlParserLAST, MySqlParserLEAVES, MySqlParserLESS, MySqlParserLEVEL, MySqlParserLIST, MySqlParserLOCAL, MySqlParserLOGFILE, MySqlParserLOGS, MySqlParserMASTER, MySqlParserMASTER_AUTO_POSITION, MySqlParserMASTER_CONNECT_RETRY, MySqlParserMASTER_DELAY, MySqlParserMASTER_HEARTBEAT_PERIOD, MySqlParserMASTER_HOST, MySqlParserMASTER_LOG_FILE, MySqlParserMASTER_LOG_POS, MySqlParserMASTER_PASSWORD, MySqlParserMASTER_PORT, MySqlParserMASTER_RETRY_COUNT, MySqlParserMASTER_SSL, MySqlParserMASTER_SSL_CA, MySqlParserMASTER_SSL_CAPATH, MySqlParserMASTER_SSL_CERT, MySqlParserMASTER_SSL_CIPHER, MySqlParserMASTER_SSL_CRL, MySqlParserMASTER_SSL_CRLPATH, MySqlParserMASTER_SSL_KEY, MySqlParserMASTER_TLS_VERSION, MySqlParserMASTER_USER, MySqlParserMAX_CONNECTIONS_PER_HOUR, MySqlParserMAX_QUERIES_PER_HOUR, MySqlParserMAX_ROWS, MySqlParserMAX_SIZE, MySqlParserMAX_UPDATES_PER_HOUR, MySqlParserMAX_USER_CONNECTIONS, MySqlParserMEDIUM, MySqlParserMEMBER, MySqlParserMERGE, MySqlParserMESSAGE_TEXT, MySqlParserMID, MySqlParserMIGRATE, MySqlParserMIN_ROWS, MySqlParserMODE, MySqlParserMODIFY, MySqlParserMUTEX, MySqlParserMYSQL, MySqlParserMYSQL_ERRNO, MySqlParserNAME, MySqlParserNAMES, MySqlParserNCHAR, MySqlParserNEVER, MySqlParserNEXT, MySqlParserNO, MySqlParserNOCOPY, MySqlParserNOWAIT, MySqlParserNODEGROUP, MySqlParserNONE, MySqlParserODBC, MySqlParserOFFLINE, MySqlParserOFFSET, MySqlParserOF, MySqlParserOJ, MySqlParserOLD_PASSWORD, MySqlParserONE, MySqlParserONLINE, MySqlParserONLY, MySqlParserOPEN, MySqlParserOPTIMIZER_COSTS, MySqlParserOPTIONS, MySqlParserOWNER, MySqlParserPACK_KEYS, MySqlParserPAGE, MySqlParserPARSER, MySqlParserPARTIAL, MySqlParserPARTITIONING, MySqlParserPARTITIONS, MySqlParserPASSWORD, MySqlParserPASSWORD_LOCK_TIME, MySqlParserPHASE, MySqlParserPLUGIN, MySqlParserPLUGIN_DIR, MySqlParserPLUGINS, MySqlParserPORT, MySqlParserPRECEDES, MySqlParserPREPARE, MySqlParserPRESERVE, MySqlParserPREV, MySqlParserPROCESSLIST, MySqlParserPROFILE, MySqlParserPROFILES, MySqlParserPROXY, MySqlParserQUERY, MySqlParserQUICK, MySqlParserREBUILD, MySqlParserRECOVER, MySqlParserRECURSIVE, MySqlParserREDO_BUFFER_SIZE, MySqlParserREDUNDANT, MySqlParserRELAY, MySqlParserRELAY_LOG_FILE, MySqlParserRELAY_LOG_POS, MySqlParserRELAYLOG, MySqlParserREMOVE, MySqlParserREORGANIZE, MySqlParserREPAIR, MySqlParserREPLICATE_DO_DB, MySqlParserREPLICATE_DO_TABLE, MySqlParserREPLICATE_IGNORE_DB, MySqlParserREPLICATE_IGNORE_TABLE, MySqlParserREPLICATE_REWRITE_DB, MySqlParserREPLICATE_WILD_DO_TABLE, MySqlParserREPLICATE_WILD_IGNORE_TABLE, MySqlParserREPLICATION, MySqlParserRESET, MySqlParserRESUME, MySqlParserRETURNED_SQLSTATE, MySqlParserRETURNING, MySqlParserRETURNS, MySqlParserREUSE, MySqlParserROLE, MySqlParserROLLBACK, MySqlParserROLLUP, MySqlParserROTATE, MySqlParserROW, MySqlParserROWS, MySqlParserROW_FORMAT, MySqlParserRTREE, MySqlParserSAVEPOINT, MySqlParserSCHEDULE, MySqlParserSECURITY, MySqlParserSERVER, MySqlParserSESSION, MySqlParserSHARE, MySqlParserSHARED, MySqlParserSIGNED, MySqlParserSIMPLE, MySqlParserSLAVE, MySqlParserSLOW, MySqlParserSNAPSHOT, MySqlParserSOCKET, MySqlParserSOME, MySqlParserSONAME, MySqlParserSOUNDS, MySqlParserSOURCE, MySqlParserSQL_AFTER_GTIDS, MySqlParserSQL_AFTER_MTS_GAPS, MySqlParserSQL_BEFORE_GTIDS, MySqlParserSQL_BUFFER_RESULT, MySqlParserSQL_CACHE, MySqlParserSQL_NO_CACHE, MySqlParserSQL_THREAD, MySqlParserSTART, MySqlParserSTARTS, MySqlParserSTATS_AUTO_RECALC, MySqlParserSTATS_PERSISTENT, MySqlParserSTATS_SAMPLE_PAGES, MySqlParserSTATUS, MySqlParserSTOP, MySqlParserSTORAGE, MySqlParserSTRING, MySqlParserSUBCLASS_ORIGIN, MySqlParserSUBJECT, MySqlParserSUBPARTITION, MySqlParserSUBPARTITIONS, MySqlParserSUSPEND, MySqlParserSWAPS, MySqlParserSWITCHES, MySqlParserTABLE_NAME, MySqlParserTABLESPACE, MySqlParserTABLE_TYPE, MySqlParserTEMPORARY, MySqlParserTEMPTABLE, MySqlParserTHAN, MySqlParserTRADITIONAL, MySqlParserTRANSACTION, MySqlParserTRANSACTIONAL, MySqlParserTRIGGERS, MySqlParserTRUNCATE, MySqlParserUNBOUNDED, MySqlParserUNDEFINED, MySqlParserUNDOFILE, MySqlParserUNDO_BUFFER_SIZE, MySqlParserUNINSTALL, MySqlParserUNKNOWN, MySqlParserUNTIL, MySqlParserUPGRADE, MySqlParserUSER, MySqlParserUSE_FRM, MySqlParserUSER_RESOURCES, MySqlParserVALIDATION, MySqlParserVALUE, MySqlParserVARIABLES, MySqlParserVIEW, MySqlParserVIRTUAL, MySqlParserVISIBLE, MySqlParserWAIT, MySqlParserWARNINGS, MySqlParserWITHOUT, MySqlParserWORK, MySqlParserWRAPPER, MySqlParserX509, MySqlParserXA, MySqlParserXML, MySqlParserYES, MySqlParserEUR, MySqlParserUSA, MySqlParserJIS, MySqlParserISO, MySqlParserINTERNAL, MySqlParserQUARTER, MySqlParserMONTH, MySqlParserDAY, MySqlParserHOUR, MySqlParserMINUTE, MySqlParserWEEK, MySqlParserSECOND, MySqlParserMICROSECOND, MySqlParserADMIN, MySqlParserAUDIT_ABORT_EXEMPT, MySqlParserAUDIT_ADMIN, MySqlParserAUTHENTICATION_POLICY_ADMIN, MySqlParserBACKUP_ADMIN, MySqlParserBINLOG_ADMIN, MySqlParserBINLOG_ENCRYPTION_ADMIN, MySqlParserCLONE_ADMIN, MySqlParserCONNECTION_ADMIN, MySqlParserENCRYPTION_KEY_ADMIN, MySqlParserEXECUTE, MySqlParserFILE, MySqlParserFIREWALL_ADMIN, MySqlParserFIREWALL_EXEMPT, MySqlParserFIREWALL_USER, MySqlParserGROUP_REPLICATION_ADMIN, MySqlParserINNODB_REDO_LOG_ARCHIVE, MySqlParserINVOKE, MySqlParserLAMBDA, MySqlParserNDB_STORED_USER, MySqlParserPASSWORDLESS_USER_ADMIN, MySqlParserPERSIST_RO_VARIABLES_ADMIN, MySqlParserPRIVILEGES, MySqlParserPROCESS, MySqlParserRELOAD, MySqlParserREPLICATION_APPLIER, MySqlParserREPLICATION_SLAVE_ADMIN, MySqlParserRESOURCE_GROUP_ADMIN, MySqlParserRESOURCE_GROUP_USER, MySqlParserROLE_ADMIN, MySqlParserROUTINE, MySqlParserS3, MySqlParserSESSION_VARIABLES_ADMIN, MySqlParserSET_USER_ID, MySqlParserSHOW_ROUTINE, MySqlParserSHUTDOWN, MySqlParserSUPER, MySqlParserSYSTEM_VARIABLES_ADMIN, MySqlParserTABLES, MySqlParserTABLE_ENCRYPTION_ADMIN, MySqlParserVERSION_TOKEN_ADMIN, MySqlParserXA_RECOVER_ADMIN, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserARCHIVE, MySqlParserBLACKHOLE, MySqlParserCSV, MySqlParserFEDERATED, MySqlParserINNODB, MySqlParserMEMORY, MySqlParserMRG_MYISAM, MySqlParserMYISAM, MySqlParserNDB, MySqlParserNDBCLUSTER, MySqlParserPERFORMANCE_SCHEMA, MySqlParserTOKUDB, MySqlParserREPEATABLE, MySqlParserCOMMITTED, MySqlParserUNCOMMITTED, MySqlParserSERIALIZABLE, MySqlParserGEOMETRYCOLLECTION, MySqlParserLINESTRING, MySqlParserMULTILINESTRING, MySqlParserMULTIPOINT, MySqlParserMULTIPOLYGON, MySqlParserPOINT, MySqlParserPOLYGON, MySqlParserABS, MySqlParserACOS, MySqlParserADDDATE, MySqlParserADDTIME, MySqlParserAES_DECRYPT, MySqlParserAES_ENCRYPT, MySqlParserAREA, MySqlParserASBINARY, MySqlParserASIN, MySqlParserASTEXT, MySqlParserASWKB, MySqlParserASWKT, MySqlParserASYMMETRIC_DECRYPT, MySqlParserASYMMETRIC_DERIVE, MySqlParserASYMMETRIC_ENCRYPT, MySqlParserASYMMETRIC_SIGN, MySqlParserASYMMETRIC_VERIFY, MySqlParserATAN, MySqlParserATAN2, MySqlParserBENCHMARK, MySqlParserBIN, MySqlParserBIT_COUNT, MySqlParserBIT_LENGTH, MySqlParserBUFFER, MySqlParserCATALOG_NAME, MySqlParserCEIL, MySqlParserCEILING, MySqlParserCENTROID, MySqlParserCHARACTER_LENGTH, MySqlParserCHARSET, MySqlParserCHAR_LENGTH, MySqlParserCOERCIBILITY, MySqlParserCOLLATION, MySqlParserCOMPRESS, MySqlParserCONCAT, MySqlParserCONCAT_WS, MySqlParserCONNECTION_ID, MySqlParserCONV, MySqlParserCONVERT_TZ, MySqlParserCOS, MySqlParserCOT, MySqlParserCRC32, MySqlParserCREATE_ASYMMETRIC_PRIV_KEY, MySqlParserCREATE_ASYMMETRIC_PUB_KEY, MySqlParserCREATE_DH_PARAMETERS, MySqlParserCREATE_DIGEST, MySqlParserCROSSES, MySqlParserDATEDIFF, MySqlParserDATE_FORMAT, MySqlParserDAYNAME, MySqlParserDAYOFMONTH, MySqlParserDAYOFWEEK, MySqlParserDAYOFYEAR, MySqlParserDECODE, MySqlParserDEGREES, MySqlParserDES_DECRYPT, MySqlParserDES_ENCRYPT, MySqlParserDIMENSION, MySqlParserDISJOINT, MySqlParserDISTANCE, MySqlParserELT, MySqlParserENCODE, MySqlParserENCRYPT, MySqlParserENDPOINT, MySqlParserENGINE_ATTRIBUTE, MySqlParserENVELOPE, MySqlParserEQUALS, MySqlParserEXP, MySqlParserEXPORT_SET, MySqlParserEXTERIORRING, MySqlParserEXTRACTVALUE, MySqlParserFIELD, MySqlParserFIND_IN_SET, MySqlParserFLOOR, MySqlParserFORMAT, MySqlParserFOUND_ROWS, MySqlParserFROM_BASE64, MySqlParserFROM_DAYS, MySqlParserFROM_UNIXTIME, MySqlParserGEOMCOLLFROMTEXT, MySqlParserGEOMCOLLFROMWKB, MySqlParserGEOMETRYCOLLECTIONFROMTEXT, MySqlParserGEOMETRYCOLLECTIONFROMWKB, MySqlParserGEOMETRYFROMTEXT, MySqlParserGEOMETRYFROMWKB, MySqlParserGEOMETRYN, MySqlParserGEOMETRYTYPE, MySqlParserGEOMFROMTEXT, MySqlParserGEOMFROMWKB, MySqlParserGET_FORMAT, MySqlParserGET_LOCK, MySqlParserGLENGTH, MySqlParserGREATEST, MySqlParserGTID_SUBSET, MySqlParserGTID_SUBTRACT, MySqlParserHEX, MySqlParserIFNULL, MySqlParserINET6_ATON, MySqlParserINET6_NTOA, MySqlParserINET_ATON, MySqlParserINET_NTOA, MySqlParserINSTR, MySqlParserINTERIORRINGN, MySqlParserINTERSECTS, MySqlParserISCLOSED, MySqlParserISEMPTY, MySqlParserISNULL, MySqlParserISSIMPLE, MySqlParserIS_FREE_LOCK, MySqlParserIS_IPV4, MySqlParserIS_IPV4_COMPAT, MySqlParserIS_IPV4_MAPPED, MySqlParserIS_IPV6, MySqlParserIS_USED_LOCK, MySqlParserLAST_INSERT_ID, MySqlParserLCASE, MySqlParserLEAST, MySqlParserLENGTH, MySqlParserLINEFROMTEXT, MySqlParserLINEFROMWKB, MySqlParserLINESTRINGFROMTEXT, MySqlParserLINESTRINGFROMWKB, MySqlParserLN, MySqlParserLOAD_FILE, MySqlParserLOCATE, MySqlParserLOG, MySqlParserLOG10, MySqlParserLOG2, MySqlParserLOWER, MySqlParserLPAD, MySqlParserLTRIM, MySqlParserMAKEDATE, MySqlParserMAKETIME, MySqlParserMAKE_SET, MySqlParserMASTER_POS_WAIT, MySqlParserMBRCONTAINS, MySqlParserMBRDISJOINT, MySqlParserMBREQUAL, MySqlParserMBRINTERSECTS, MySqlParserMBROVERLAPS, MySqlParserMBRTOUCHES, MySqlParserMBRWITHIN, MySqlParserMD5, MySqlParserMLINEFROMTEXT, MySqlParserMLINEFROMWKB, MySqlParserMONTHNAME, MySqlParserMPOINTFROMTEXT, MySqlParserMPOINTFROMWKB, MySqlParserMPOLYFROMTEXT, MySqlParserMPOLYFROMWKB, MySqlParserMULTILINESTRINGFROMTEXT, MySqlParserMULTILINESTRINGFROMWKB, MySqlParserMULTIPOINTFROMTEXT, MySqlParserMULTIPOINTFROMWKB, MySqlParserMULTIPOLYGONFROMTEXT, MySqlParserMULTIPOLYGONFROMWKB, MySqlParserNAME_CONST, MySqlParserNULLIF, MySqlParserNUMGEOMETRIES, MySqlParserNUMINTERIORRINGS, MySqlParserNUMPOINTS, MySqlParserOCT, MySqlParserOCTET_LENGTH, MySqlParserORD, MySqlParserOVERLAPS, MySqlParserPERIOD_ADD, MySqlParserPERIOD_DIFF, MySqlParserPI, MySqlParserPOINTFROMTEXT, MySqlParserPOINTFROMWKB, MySqlParserPOINTN, MySqlParserPOLYFROMTEXT, MySqlParserPOLYFROMWKB, MySqlParserPOLYGONFROMTEXT, MySqlParserPOLYGONFROMWKB, MySqlParserPOW, MySqlParserPOWER, MySqlParserQUOTE, MySqlParserRADIANS, MySqlParserRAND, MySqlParserRANDOM, MySqlParserRANDOM_BYTES, MySqlParserRELEASE_LOCK, MySqlParserREVERSE, MySqlParserROUND, MySqlParserROW_COUNT, MySqlParserRPAD, MySqlParserRTRIM, MySqlParserSEC_TO_TIME, MySqlParserSECONDARY_ENGINE_ATTRIBUTE, MySqlParserSESSION_USER, MySqlParserSHA, MySqlParserSHA1, MySqlParserSHA2, MySqlParserSCHEMA_NAME, MySqlParserSIGN, MySqlParserSIN, MySqlParserSLEEP, MySqlParserSOUNDEX, MySqlParserSQL_THREAD_WAIT_AFTER_GTIDS, MySqlParserSQRT, MySqlParserSRID, MySqlParserSTARTPOINT, MySqlParserSTRCMP, MySqlParserSTR_TO_DATE, MySqlParserST_AREA, MySqlParserST_ASBINARY, MySqlParserST_ASTEXT, MySqlParserST_ASWKB, MySqlParserST_ASWKT, MySqlParserST_BUFFER, MySqlParserST_CENTROID, MySqlParserST_CONTAINS, MySqlParserST_CROSSES, MySqlParserST_DIFFERENCE, MySqlParserST_DIMENSION, MySqlParserST_DISJOINT, MySqlParserST_DISTANCE, MySqlParserST_ENDPOINT, MySqlParserST_ENVELOPE, MySqlParserST_EQUALS, MySqlParserST_EXTERIORRING, MySqlParserST_GEOMCOLLFROMTEXT, MySqlParserST_GEOMCOLLFROMTXT, MySqlParserST_GEOMCOLLFROMWKB, MySqlParserST_GEOMETRYCOLLECTIONFROMTEXT, MySqlParserST_GEOMETRYCOLLECTIONFROMWKB, MySqlParserST_GEOMETRYFROMTEXT, MySqlParserST_GEOMETRYFROMWKB, MySqlParserST_GEOMETRYN, MySqlParserST_GEOMETRYTYPE, MySqlParserST_GEOMFROMTEXT, MySqlParserST_GEOMFROMWKB, MySqlParserST_INTERIORRINGN, MySqlParserST_INTERSECTION, MySqlParserST_INTERSECTS, MySqlParserST_ISCLOSED, MySqlParserST_ISEMPTY, MySqlParserST_ISSIMPLE, MySqlParserST_LINEFROMTEXT, MySqlParserST_LINEFROMWKB, MySqlParserST_LINESTRINGFROMTEXT, MySqlParserST_LINESTRINGFROMWKB, MySqlParserST_NUMGEOMETRIES, MySqlParserST_NUMINTERIORRING, MySqlParserST_NUMINTERIORRINGS, MySqlParserST_NUMPOINTS, MySqlParserST_OVERLAPS, MySqlParserST_POINTFROMTEXT, MySqlParserST_POINTFROMWKB, MySqlParserST_POINTN, MySqlParserST_POLYFROMTEXT, MySqlParserST_POLYFROMWKB, MySqlParserST_POLYGONFROMTEXT, MySqlParserST_POLYGONFROMWKB, MySqlParserST_SRID, MySqlParserST_STARTPOINT, MySqlParserST_SYMDIFFERENCE, MySqlParserST_TOUCHES, MySqlParserST_UNION, MySqlParserST_WITHIN, MySqlParserST_X, MySqlParserST_Y, MySqlParserSTRING_TO_VECTOR, MySqlParserSUBDATE, MySqlParserSUBSTRING_INDEX, MySqlParserSUBTIME, MySqlParserSYSTEM_USER, MySqlParserTAN, MySqlParserTIMEDIFF, MySqlParserTIMESTAMPADD, MySqlParserTIMESTAMPDIFF, MySqlParserTIME_FORMAT, MySqlParserTIME_TO_SEC, MySqlParserTOUCHES, MySqlParserTO_BASE64, MySqlParserTO_DAYS, MySqlParserTO_SECONDS, MySqlParserTP_CONNECTION_ADMIN, MySqlParserUCASE, MySqlParserUNCOMPRESS, MySqlParserUNCOMPRESSED_LENGTH, MySqlParserUNHEX, MySqlParserUNIX_TIMESTAMP, MySqlParserUPDATEXML, MySqlParserUPPER, MySqlParserUUID, MySqlParserUUID_SHORT, MySqlParserVALIDATE_PASSWORD_STRENGTH, MySqlParserVECTOR_DIM, MySqlParserVECTOR_TO_STRING, MySqlParserVERSION, MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS, MySqlParserWEEKDAY, MySqlParserWEEKOFYEAR, MySqlParserWEIGHT_STRING, MySqlParserWITHIN, MySqlParserYEARWEEK, MySqlParserY_FUNCTION, MySqlParserX_FUNCTION, MySqlParserMOD, MySqlParserID: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6413) + p.SimpleId() + } + + case MySqlParserCHARSET_REVERSE_QOUTE_STRING: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6414) + p.Match(MySqlParserCHARSET_REVERSE_QOUTE_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserSTRING_LITERAL: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6415) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISimpleIdContext is an interface to support dynamic dispatch. +type ISimpleIdContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ID() antlr.TerminalNode + CharsetNameBase() ICharsetNameBaseContext + TransactionLevelBase() ITransactionLevelBaseContext + EngineNameBase() IEngineNameBaseContext + PrivilegesBase() IPrivilegesBaseContext + IntervalTypeBase() IIntervalTypeBaseContext + DataTypeBase() IDataTypeBaseContext + KeywordsCanBeId() IKeywordsCanBeIdContext + ScalarFunctionName() IScalarFunctionNameContext + + // IsSimpleIdContext differentiates from other interfaces. + IsSimpleIdContext() +} + +type SimpleIdContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySimpleIdContext() *SimpleIdContext { + var p = new(SimpleIdContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_simpleId + return p +} + +func InitEmptySimpleIdContext(p *SimpleIdContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_simpleId +} + +func (*SimpleIdContext) IsSimpleIdContext() {} + +func NewSimpleIdContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SimpleIdContext { + var p = new(SimpleIdContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_simpleId + + return p +} + +func (s *SimpleIdContext) GetParser() antlr.Parser { return s.parser } + +func (s *SimpleIdContext) ID() antlr.TerminalNode { + return s.GetToken(MySqlParserID, 0) +} + +func (s *SimpleIdContext) CharsetNameBase() ICharsetNameBaseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICharsetNameBaseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICharsetNameBaseContext) +} + +func (s *SimpleIdContext) TransactionLevelBase() ITransactionLevelBaseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITransactionLevelBaseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITransactionLevelBaseContext) +} + +func (s *SimpleIdContext) EngineNameBase() IEngineNameBaseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEngineNameBaseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEngineNameBaseContext) +} + +func (s *SimpleIdContext) PrivilegesBase() IPrivilegesBaseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrivilegesBaseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrivilegesBaseContext) +} + +func (s *SimpleIdContext) IntervalTypeBase() IIntervalTypeBaseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIntervalTypeBaseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIntervalTypeBaseContext) +} + +func (s *SimpleIdContext) DataTypeBase() IDataTypeBaseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDataTypeBaseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDataTypeBaseContext) +} + +func (s *SimpleIdContext) KeywordsCanBeId() IKeywordsCanBeIdContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeywordsCanBeIdContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeywordsCanBeIdContext) +} + +func (s *SimpleIdContext) ScalarFunctionName() IScalarFunctionNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IScalarFunctionNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IScalarFunctionNameContext) +} + +func (s *SimpleIdContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SimpleIdContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SimpleIdContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSimpleId(s) + } +} + +func (s *SimpleIdContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSimpleId(s) + } +} + +func (p *MySqlParser) SimpleId() (localctx ISimpleIdContext) { + localctx = NewSimpleIdContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 586, MySqlParserRULE_simpleId) + p.SetState(6427) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 947, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6418) + p.Match(MySqlParserID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6419) + p.CharsetNameBase() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6420) + p.TransactionLevelBase() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(6421) + p.EngineNameBase() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(6422) + p.PrivilegesBase() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(6423) + p.IntervalTypeBase() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(6424) + p.DataTypeBase() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(6425) + p.KeywordsCanBeId() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(6426) + p.ScalarFunctionName() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDottedIdContext is an interface to support dynamic dispatch. +type IDottedIdContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DOT_ID() antlr.TerminalNode + DOT() antlr.TerminalNode + Uid() IUidContext + + // IsDottedIdContext differentiates from other interfaces. + IsDottedIdContext() +} + +type DottedIdContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDottedIdContext() *DottedIdContext { + var p = new(DottedIdContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_dottedId + return p +} + +func InitEmptyDottedIdContext(p *DottedIdContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_dottedId +} + +func (*DottedIdContext) IsDottedIdContext() {} + +func NewDottedIdContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DottedIdContext { + var p = new(DottedIdContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_dottedId + + return p +} + +func (s *DottedIdContext) GetParser() antlr.Parser { return s.parser } + +func (s *DottedIdContext) DOT_ID() antlr.TerminalNode { + return s.GetToken(MySqlParserDOT_ID, 0) +} + +func (s *DottedIdContext) DOT() antlr.TerminalNode { + return s.GetToken(MySqlParserDOT, 0) +} + +func (s *DottedIdContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *DottedIdContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DottedIdContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DottedIdContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterDottedId(s) + } +} + +func (s *DottedIdContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitDottedId(s) + } +} + +func (p *MySqlParser) DottedId() (localctx IDottedIdContext) { + localctx = NewDottedIdContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 588, MySqlParserRULE_dottedId) + p.SetState(6432) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserDOT_ID: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6429) + p.Match(MySqlParserDOT_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserDOT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6430) + p.Match(MySqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6431) + p.Uid() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDecimalLiteralContext is an interface to support dynamic dispatch. +type IDecimalLiteralContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DECIMAL_LITERAL() antlr.TerminalNode + ZERO_DECIMAL() antlr.TerminalNode + ONE_DECIMAL() antlr.TerminalNode + TWO_DECIMAL() antlr.TerminalNode + REAL_LITERAL() antlr.TerminalNode + + // IsDecimalLiteralContext differentiates from other interfaces. + IsDecimalLiteralContext() +} + +type DecimalLiteralContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDecimalLiteralContext() *DecimalLiteralContext { + var p = new(DecimalLiteralContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_decimalLiteral + return p +} + +func InitEmptyDecimalLiteralContext(p *DecimalLiteralContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_decimalLiteral +} + +func (*DecimalLiteralContext) IsDecimalLiteralContext() {} + +func NewDecimalLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DecimalLiteralContext { + var p = new(DecimalLiteralContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_decimalLiteral + + return p +} + +func (s *DecimalLiteralContext) GetParser() antlr.Parser { return s.parser } + +func (s *DecimalLiteralContext) DECIMAL_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserDECIMAL_LITERAL, 0) +} + +func (s *DecimalLiteralContext) ZERO_DECIMAL() antlr.TerminalNode { + return s.GetToken(MySqlParserZERO_DECIMAL, 0) +} + +func (s *DecimalLiteralContext) ONE_DECIMAL() antlr.TerminalNode { + return s.GetToken(MySqlParserONE_DECIMAL, 0) +} + +func (s *DecimalLiteralContext) TWO_DECIMAL() antlr.TerminalNode { + return s.GetToken(MySqlParserTWO_DECIMAL, 0) +} + +func (s *DecimalLiteralContext) REAL_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserREAL_LITERAL, 0) +} + +func (s *DecimalLiteralContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DecimalLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DecimalLiteralContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterDecimalLiteral(s) + } +} + +func (s *DecimalLiteralContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitDecimalLiteral(s) + } +} + +func (p *MySqlParser) DecimalLiteral() (localctx IDecimalLiteralContext) { + localctx = NewDecimalLiteralContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 590, MySqlParserRULE_decimalLiteral) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6434) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-1143)) & ^0x3f) == 0 && ((int64(1)<<(_la-1143))&10247) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFileSizeLiteralContext is an interface to support dynamic dispatch. +type IFileSizeLiteralContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FILESIZE_LITERAL() antlr.TerminalNode + DecimalLiteral() IDecimalLiteralContext + + // IsFileSizeLiteralContext differentiates from other interfaces. + IsFileSizeLiteralContext() +} + +type FileSizeLiteralContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFileSizeLiteralContext() *FileSizeLiteralContext { + var p = new(FileSizeLiteralContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_fileSizeLiteral + return p +} + +func InitEmptyFileSizeLiteralContext(p *FileSizeLiteralContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_fileSizeLiteral +} + +func (*FileSizeLiteralContext) IsFileSizeLiteralContext() {} + +func NewFileSizeLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FileSizeLiteralContext { + var p = new(FileSizeLiteralContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_fileSizeLiteral + + return p +} + +func (s *FileSizeLiteralContext) GetParser() antlr.Parser { return s.parser } + +func (s *FileSizeLiteralContext) FILESIZE_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserFILESIZE_LITERAL, 0) +} + +func (s *FileSizeLiteralContext) DecimalLiteral() IDecimalLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *FileSizeLiteralContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FileSizeLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FileSizeLiteralContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterFileSizeLiteral(s) + } +} + +func (s *FileSizeLiteralContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitFileSizeLiteral(s) + } +} + +func (p *MySqlParser) FileSizeLiteral() (localctx IFileSizeLiteralContext) { + localctx = NewFileSizeLiteralContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 592, MySqlParserRULE_fileSizeLiteral) + p.SetState(6438) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserFILESIZE_LITERAL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6436) + p.Match(MySqlParserFILESIZE_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserZERO_DECIMAL, MySqlParserONE_DECIMAL, MySqlParserTWO_DECIMAL, MySqlParserDECIMAL_LITERAL, MySqlParserREAL_LITERAL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6437) + p.DecimalLiteral() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStringLiteralContext is an interface to support dynamic dispatch. +type IStringLiteralContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllSTRING_LITERAL() []antlr.TerminalNode + STRING_LITERAL(i int) antlr.TerminalNode + START_NATIONAL_STRING_LITERAL() antlr.TerminalNode + STRING_CHARSET_NAME() antlr.TerminalNode + COLLATE() antlr.TerminalNode + CollationName() ICollationNameContext + + // IsStringLiteralContext differentiates from other interfaces. + IsStringLiteralContext() +} + +type StringLiteralContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStringLiteralContext() *StringLiteralContext { + var p = new(StringLiteralContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_stringLiteral + return p +} + +func InitEmptyStringLiteralContext(p *StringLiteralContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_stringLiteral +} + +func (*StringLiteralContext) IsStringLiteralContext() {} + +func NewStringLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StringLiteralContext { + var p = new(StringLiteralContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_stringLiteral + + return p +} + +func (s *StringLiteralContext) GetParser() antlr.Parser { return s.parser } + +func (s *StringLiteralContext) AllSTRING_LITERAL() []antlr.TerminalNode { + return s.GetTokens(MySqlParserSTRING_LITERAL) +} + +func (s *StringLiteralContext) STRING_LITERAL(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, i) +} + +func (s *StringLiteralContext) START_NATIONAL_STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTART_NATIONAL_STRING_LITERAL, 0) +} + +func (s *StringLiteralContext) STRING_CHARSET_NAME() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_CHARSET_NAME, 0) +} + +func (s *StringLiteralContext) COLLATE() antlr.TerminalNode { + return s.GetToken(MySqlParserCOLLATE, 0) +} + +func (s *StringLiteralContext) CollationName() ICollationNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICollationNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICollationNameContext) +} + +func (s *StringLiteralContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *StringLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *StringLiteralContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterStringLiteral(s) + } +} + +func (s *StringLiteralContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitStringLiteral(s) + } +} + +func (p *MySqlParser) StringLiteral() (localctx IStringLiteralContext) { + localctx = NewStringLiteralContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 594, MySqlParserRULE_stringLiteral) + var _la int + + var _alt int + + p.SetState(6463) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 956, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(6445) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserSTRING_LITERAL, MySqlParserSTRING_CHARSET_NAME: + p.SetState(6441) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserSTRING_CHARSET_NAME { + { + p.SetState(6440) + p.Match(MySqlParserSTRING_CHARSET_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6443) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserSTART_NATIONAL_STRING_LITERAL: + { + p.SetState(6444) + p.Match(MySqlParserSTART_NATIONAL_STRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(6448) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(6447) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(6450) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 952, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + p.SetState(6457) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserSTRING_LITERAL, MySqlParserSTRING_CHARSET_NAME: + p.SetState(6453) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserSTRING_CHARSET_NAME { + { + p.SetState(6452) + p.Match(MySqlParserSTRING_CHARSET_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6455) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserSTART_NATIONAL_STRING_LITERAL: + { + p.SetState(6456) + p.Match(MySqlParserSTART_NATIONAL_STRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(6461) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 955, p.GetParserRuleContext()) == 1 { + { + p.SetState(6459) + p.Match(MySqlParserCOLLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6460) + p.CollationName() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBooleanLiteralContext is an interface to support dynamic dispatch. +type IBooleanLiteralContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TRUE() antlr.TerminalNode + FALSE() antlr.TerminalNode + + // IsBooleanLiteralContext differentiates from other interfaces. + IsBooleanLiteralContext() +} + +type BooleanLiteralContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBooleanLiteralContext() *BooleanLiteralContext { + var p = new(BooleanLiteralContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_booleanLiteral + return p +} + +func InitEmptyBooleanLiteralContext(p *BooleanLiteralContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_booleanLiteral +} + +func (*BooleanLiteralContext) IsBooleanLiteralContext() {} + +func NewBooleanLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BooleanLiteralContext { + var p = new(BooleanLiteralContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_booleanLiteral + + return p +} + +func (s *BooleanLiteralContext) GetParser() antlr.Parser { return s.parser } + +func (s *BooleanLiteralContext) TRUE() antlr.TerminalNode { + return s.GetToken(MySqlParserTRUE, 0) +} + +func (s *BooleanLiteralContext) FALSE() antlr.TerminalNode { + return s.GetToken(MySqlParserFALSE, 0) +} + +func (s *BooleanLiteralContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *BooleanLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *BooleanLiteralContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterBooleanLiteral(s) + } +} + +func (s *BooleanLiteralContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitBooleanLiteral(s) + } +} + +func (p *MySqlParser) BooleanLiteral() (localctx IBooleanLiteralContext) { + localctx = NewBooleanLiteralContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 596, MySqlParserRULE_booleanLiteral) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6465) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserFALSE || _la == MySqlParserTRUE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHexadecimalLiteralContext is an interface to support dynamic dispatch. +type IHexadecimalLiteralContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + HEXADECIMAL_LITERAL() antlr.TerminalNode + STRING_CHARSET_NAME() antlr.TerminalNode + + // IsHexadecimalLiteralContext differentiates from other interfaces. + IsHexadecimalLiteralContext() +} + +type HexadecimalLiteralContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHexadecimalLiteralContext() *HexadecimalLiteralContext { + var p = new(HexadecimalLiteralContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_hexadecimalLiteral + return p +} + +func InitEmptyHexadecimalLiteralContext(p *HexadecimalLiteralContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_hexadecimalLiteral +} + +func (*HexadecimalLiteralContext) IsHexadecimalLiteralContext() {} + +func NewHexadecimalLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *HexadecimalLiteralContext { + var p = new(HexadecimalLiteralContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_hexadecimalLiteral + + return p +} + +func (s *HexadecimalLiteralContext) GetParser() antlr.Parser { return s.parser } + +func (s *HexadecimalLiteralContext) HEXADECIMAL_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserHEXADECIMAL_LITERAL, 0) +} + +func (s *HexadecimalLiteralContext) STRING_CHARSET_NAME() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_CHARSET_NAME, 0) +} + +func (s *HexadecimalLiteralContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *HexadecimalLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *HexadecimalLiteralContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterHexadecimalLiteral(s) + } +} + +func (s *HexadecimalLiteralContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitHexadecimalLiteral(s) + } +} + +func (p *MySqlParser) HexadecimalLiteral() (localctx IHexadecimalLiteralContext) { + localctx = NewHexadecimalLiteralContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 598, MySqlParserRULE_hexadecimalLiteral) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(6468) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserSTRING_CHARSET_NAME { + { + p.SetState(6467) + p.Match(MySqlParserSTRING_CHARSET_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6470) + p.Match(MySqlParserHEXADECIMAL_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INullNotnullContext is an interface to support dynamic dispatch. +type INullNotnullContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NULL_LITERAL() antlr.TerminalNode + NULL_SPEC_LITERAL() antlr.TerminalNode + NOT() antlr.TerminalNode + + // IsNullNotnullContext differentiates from other interfaces. + IsNullNotnullContext() +} + +type NullNotnullContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNullNotnullContext() *NullNotnullContext { + var p = new(NullNotnullContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_nullNotnull + return p +} + +func InitEmptyNullNotnullContext(p *NullNotnullContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_nullNotnull +} + +func (*NullNotnullContext) IsNullNotnullContext() {} + +func NewNullNotnullContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NullNotnullContext { + var p = new(NullNotnullContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_nullNotnull + + return p +} + +func (s *NullNotnullContext) GetParser() antlr.Parser { return s.parser } + +func (s *NullNotnullContext) NULL_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserNULL_LITERAL, 0) +} + +func (s *NullNotnullContext) NULL_SPEC_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserNULL_SPEC_LITERAL, 0) +} + +func (s *NullNotnullContext) NOT() antlr.TerminalNode { + return s.GetToken(MySqlParserNOT, 0) +} + +func (s *NullNotnullContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *NullNotnullContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *NullNotnullContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterNullNotnull(s) + } +} + +func (s *NullNotnullContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitNullNotnull(s) + } +} + +func (p *MySqlParser) NullNotnull() (localctx INullNotnullContext) { + localctx = NewNullNotnullContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 600, MySqlParserRULE_nullNotnull) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(6473) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserNOT { + { + p.SetState(6472) + p.Match(MySqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6475) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserNULL_LITERAL || _la == MySqlParserNULL_SPEC_LITERAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IConstantContext is an interface to support dynamic dispatch. +type IConstantContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetNullLiteral returns the nullLiteral token. + GetNullLiteral() antlr.Token + + // SetNullLiteral sets the nullLiteral token. + SetNullLiteral(antlr.Token) + + // Getter signatures + StringLiteral() IStringLiteralContext + DecimalLiteral() IDecimalLiteralContext + MINUS() antlr.TerminalNode + HexadecimalLiteral() IHexadecimalLiteralContext + BooleanLiteral() IBooleanLiteralContext + REAL_LITERAL() antlr.TerminalNode + BIT_STRING() antlr.TerminalNode + NULL_LITERAL() antlr.TerminalNode + NULL_SPEC_LITERAL() antlr.TerminalNode + NOT() antlr.TerminalNode + + // IsConstantContext differentiates from other interfaces. + IsConstantContext() +} + +type ConstantContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + nullLiteral antlr.Token +} + +func NewEmptyConstantContext() *ConstantContext { + var p = new(ConstantContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_constant + return p +} + +func InitEmptyConstantContext(p *ConstantContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_constant +} + +func (*ConstantContext) IsConstantContext() {} + +func NewConstantContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstantContext { + var p = new(ConstantContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_constant + + return p +} + +func (s *ConstantContext) GetParser() antlr.Parser { return s.parser } + +func (s *ConstantContext) GetNullLiteral() antlr.Token { return s.nullLiteral } + +func (s *ConstantContext) SetNullLiteral(v antlr.Token) { s.nullLiteral = v } + +func (s *ConstantContext) StringLiteral() IStringLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringLiteralContext) +} + +func (s *ConstantContext) DecimalLiteral() IDecimalLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *ConstantContext) MINUS() antlr.TerminalNode { + return s.GetToken(MySqlParserMINUS, 0) +} + +func (s *ConstantContext) HexadecimalLiteral() IHexadecimalLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHexadecimalLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHexadecimalLiteralContext) +} + +func (s *ConstantContext) BooleanLiteral() IBooleanLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBooleanLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBooleanLiteralContext) +} + +func (s *ConstantContext) REAL_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserREAL_LITERAL, 0) +} + +func (s *ConstantContext) BIT_STRING() antlr.TerminalNode { + return s.GetToken(MySqlParserBIT_STRING, 0) +} + +func (s *ConstantContext) NULL_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserNULL_LITERAL, 0) +} + +func (s *ConstantContext) NULL_SPEC_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserNULL_SPEC_LITERAL, 0) +} + +func (s *ConstantContext) NOT() antlr.TerminalNode { + return s.GetToken(MySqlParserNOT, 0) +} + +func (s *ConstantContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ConstantContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ConstantContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterConstant(s) + } +} + +func (s *ConstantContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitConstant(s) + } +} + +func (p *MySqlParser) Constant() (localctx IConstantContext) { + localctx = NewConstantContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 602, MySqlParserRULE_constant) + var _la int + + p.SetState(6489) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 960, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6477) + p.StringLiteral() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6478) + p.DecimalLiteral() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6479) + p.Match(MySqlParserMINUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6480) + p.DecimalLiteral() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(6481) + p.HexadecimalLiteral() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(6482) + p.BooleanLiteral() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(6483) + p.Match(MySqlParserREAL_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(6484) + p.Match(MySqlParserBIT_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + p.EnterOuterAlt(localctx, 8) + p.SetState(6486) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserNOT { + { + p.SetState(6485) + p.Match(MySqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6488) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*ConstantContext).nullLiteral = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserNULL_LITERAL || _la == MySqlParserNULL_SPEC_LITERAL) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*ConstantContext).nullLiteral = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDataTypeContext is an interface to support dynamic dispatch. +type IDataTypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsDataTypeContext differentiates from other interfaces. + IsDataTypeContext() +} + +type DataTypeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDataTypeContext() *DataTypeContext { + var p = new(DataTypeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_dataType + return p +} + +func InitEmptyDataTypeContext(p *DataTypeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_dataType +} + +func (*DataTypeContext) IsDataTypeContext() {} + +func NewDataTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DataTypeContext { + var p = new(DataTypeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_dataType + + return p +} + +func (s *DataTypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *DataTypeContext) CopyAll(ctx *DataTypeContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *DataTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DataTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type SpatialDataTypeContext struct { + DataTypeContext + typeName antlr.Token +} + +func NewSpatialDataTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SpatialDataTypeContext { + var p = new(SpatialDataTypeContext) + + InitEmptyDataTypeContext(&p.DataTypeContext) + p.parser = parser + p.CopyAll(ctx.(*DataTypeContext)) + + return p +} + +func (s *SpatialDataTypeContext) GetTypeName() antlr.Token { return s.typeName } + +func (s *SpatialDataTypeContext) SetTypeName(v antlr.Token) { s.typeName = v } + +func (s *SpatialDataTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SpatialDataTypeContext) GEOMETRYCOLLECTION() antlr.TerminalNode { + return s.GetToken(MySqlParserGEOMETRYCOLLECTION, 0) +} + +func (s *SpatialDataTypeContext) GEOMCOLLECTION() antlr.TerminalNode { + return s.GetToken(MySqlParserGEOMCOLLECTION, 0) +} + +func (s *SpatialDataTypeContext) LINESTRING() antlr.TerminalNode { + return s.GetToken(MySqlParserLINESTRING, 0) +} + +func (s *SpatialDataTypeContext) MULTILINESTRING() antlr.TerminalNode { + return s.GetToken(MySqlParserMULTILINESTRING, 0) +} + +func (s *SpatialDataTypeContext) MULTIPOINT() antlr.TerminalNode { + return s.GetToken(MySqlParserMULTIPOINT, 0) +} + +func (s *SpatialDataTypeContext) MULTIPOLYGON() antlr.TerminalNode { + return s.GetToken(MySqlParserMULTIPOLYGON, 0) +} + +func (s *SpatialDataTypeContext) POINT() antlr.TerminalNode { + return s.GetToken(MySqlParserPOINT, 0) +} + +func (s *SpatialDataTypeContext) POLYGON() antlr.TerminalNode { + return s.GetToken(MySqlParserPOLYGON, 0) +} + +func (s *SpatialDataTypeContext) JSON() antlr.TerminalNode { + return s.GetToken(MySqlParserJSON, 0) +} + +func (s *SpatialDataTypeContext) GEOMETRY() antlr.TerminalNode { + return s.GetToken(MySqlParserGEOMETRY, 0) +} + +func (s *SpatialDataTypeContext) SRID() antlr.TerminalNode { + return s.GetToken(MySqlParserSRID, 0) +} + +func (s *SpatialDataTypeContext) DecimalLiteral() IDecimalLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *SpatialDataTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSpatialDataType(s) + } +} + +func (s *SpatialDataTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSpatialDataType(s) + } +} + +type LongVarbinaryDataTypeContext struct { + DataTypeContext +} + +func NewLongVarbinaryDataTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LongVarbinaryDataTypeContext { + var p = new(LongVarbinaryDataTypeContext) + + InitEmptyDataTypeContext(&p.DataTypeContext) + p.parser = parser + p.CopyAll(ctx.(*DataTypeContext)) + + return p +} + +func (s *LongVarbinaryDataTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LongVarbinaryDataTypeContext) LONG() antlr.TerminalNode { + return s.GetToken(MySqlParserLONG, 0) +} + +func (s *LongVarbinaryDataTypeContext) VARBINARY() antlr.TerminalNode { + return s.GetToken(MySqlParserVARBINARY, 0) +} + +func (s *LongVarbinaryDataTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterLongVarbinaryDataType(s) + } +} + +func (s *LongVarbinaryDataTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitLongVarbinaryDataType(s) + } +} + +type CollectionDataTypeContext struct { + DataTypeContext + typeName antlr.Token +} + +func NewCollectionDataTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CollectionDataTypeContext { + var p = new(CollectionDataTypeContext) + + InitEmptyDataTypeContext(&p.DataTypeContext) + p.parser = parser + p.CopyAll(ctx.(*DataTypeContext)) + + return p +} + +func (s *CollectionDataTypeContext) GetTypeName() antlr.Token { return s.typeName } + +func (s *CollectionDataTypeContext) SetTypeName(v antlr.Token) { s.typeName = v } + +func (s *CollectionDataTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CollectionDataTypeContext) CollectionOptions() ICollectionOptionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICollectionOptionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICollectionOptionsContext) +} + +func (s *CollectionDataTypeContext) ENUM() antlr.TerminalNode { + return s.GetToken(MySqlParserENUM, 0) +} + +func (s *CollectionDataTypeContext) SET() antlr.TerminalNode { + return s.GetToken(MySqlParserSET, 0) +} + +func (s *CollectionDataTypeContext) BINARY() antlr.TerminalNode { + return s.GetToken(MySqlParserBINARY, 0) +} + +func (s *CollectionDataTypeContext) CharSet() ICharSetContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICharSetContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICharSetContext) +} + +func (s *CollectionDataTypeContext) CharsetName() ICharsetNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICharsetNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICharsetNameContext) +} + +func (s *CollectionDataTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCollectionDataType(s) + } +} + +func (s *CollectionDataTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCollectionDataType(s) + } +} + +type NationalVaryingStringDataTypeContext struct { + DataTypeContext + typeName antlr.Token +} + +func NewNationalVaryingStringDataTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NationalVaryingStringDataTypeContext { + var p = new(NationalVaryingStringDataTypeContext) + + InitEmptyDataTypeContext(&p.DataTypeContext) + p.parser = parser + p.CopyAll(ctx.(*DataTypeContext)) + + return p +} + +func (s *NationalVaryingStringDataTypeContext) GetTypeName() antlr.Token { return s.typeName } + +func (s *NationalVaryingStringDataTypeContext) SetTypeName(v antlr.Token) { s.typeName = v } + +func (s *NationalVaryingStringDataTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *NationalVaryingStringDataTypeContext) NATIONAL() antlr.TerminalNode { + return s.GetToken(MySqlParserNATIONAL, 0) +} + +func (s *NationalVaryingStringDataTypeContext) VARYING() antlr.TerminalNode { + return s.GetToken(MySqlParserVARYING, 0) +} + +func (s *NationalVaryingStringDataTypeContext) CHAR() antlr.TerminalNode { + return s.GetToken(MySqlParserCHAR, 0) +} + +func (s *NationalVaryingStringDataTypeContext) CHARACTER() antlr.TerminalNode { + return s.GetToken(MySqlParserCHARACTER, 0) +} + +func (s *NationalVaryingStringDataTypeContext) LengthOneDimension() ILengthOneDimensionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILengthOneDimensionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILengthOneDimensionContext) +} + +func (s *NationalVaryingStringDataTypeContext) BINARY() antlr.TerminalNode { + return s.GetToken(MySqlParserBINARY, 0) +} + +func (s *NationalVaryingStringDataTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterNationalVaryingStringDataType(s) + } +} + +func (s *NationalVaryingStringDataTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitNationalVaryingStringDataType(s) + } +} + +type DimensionDataTypeContext struct { + DataTypeContext + typeName antlr.Token +} + +func NewDimensionDataTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DimensionDataTypeContext { + var p = new(DimensionDataTypeContext) + + InitEmptyDataTypeContext(&p.DataTypeContext) + p.parser = parser + p.CopyAll(ctx.(*DataTypeContext)) + + return p +} + +func (s *DimensionDataTypeContext) GetTypeName() antlr.Token { return s.typeName } + +func (s *DimensionDataTypeContext) SetTypeName(v antlr.Token) { s.typeName = v } + +func (s *DimensionDataTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DimensionDataTypeContext) TINYINT() antlr.TerminalNode { + return s.GetToken(MySqlParserTINYINT, 0) +} + +func (s *DimensionDataTypeContext) SMALLINT() antlr.TerminalNode { + return s.GetToken(MySqlParserSMALLINT, 0) +} + +func (s *DimensionDataTypeContext) MEDIUMINT() antlr.TerminalNode { + return s.GetToken(MySqlParserMEDIUMINT, 0) +} + +func (s *DimensionDataTypeContext) INT() antlr.TerminalNode { + return s.GetToken(MySqlParserINT, 0) +} + +func (s *DimensionDataTypeContext) INTEGER() antlr.TerminalNode { + return s.GetToken(MySqlParserINTEGER, 0) +} + +func (s *DimensionDataTypeContext) BIGINT() antlr.TerminalNode { + return s.GetToken(MySqlParserBIGINT, 0) +} + +func (s *DimensionDataTypeContext) MIDDLEINT() antlr.TerminalNode { + return s.GetToken(MySqlParserMIDDLEINT, 0) +} + +func (s *DimensionDataTypeContext) INT1() antlr.TerminalNode { + return s.GetToken(MySqlParserINT1, 0) +} + +func (s *DimensionDataTypeContext) INT2() antlr.TerminalNode { + return s.GetToken(MySqlParserINT2, 0) +} + +func (s *DimensionDataTypeContext) INT3() antlr.TerminalNode { + return s.GetToken(MySqlParserINT3, 0) +} + +func (s *DimensionDataTypeContext) INT4() antlr.TerminalNode { + return s.GetToken(MySqlParserINT4, 0) +} + +func (s *DimensionDataTypeContext) INT8() antlr.TerminalNode { + return s.GetToken(MySqlParserINT8, 0) +} + +func (s *DimensionDataTypeContext) LengthOneDimension() ILengthOneDimensionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILengthOneDimensionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILengthOneDimensionContext) +} + +func (s *DimensionDataTypeContext) AllSIGNED() []antlr.TerminalNode { + return s.GetTokens(MySqlParserSIGNED) +} + +func (s *DimensionDataTypeContext) SIGNED(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserSIGNED, i) +} + +func (s *DimensionDataTypeContext) AllUNSIGNED() []antlr.TerminalNode { + return s.GetTokens(MySqlParserUNSIGNED) +} + +func (s *DimensionDataTypeContext) UNSIGNED(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserUNSIGNED, i) +} + +func (s *DimensionDataTypeContext) AllZEROFILL() []antlr.TerminalNode { + return s.GetTokens(MySqlParserZEROFILL) +} + +func (s *DimensionDataTypeContext) ZEROFILL(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserZEROFILL, i) +} + +func (s *DimensionDataTypeContext) REAL() antlr.TerminalNode { + return s.GetToken(MySqlParserREAL, 0) +} + +func (s *DimensionDataTypeContext) LengthTwoDimension() ILengthTwoDimensionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILengthTwoDimensionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILengthTwoDimensionContext) +} + +func (s *DimensionDataTypeContext) DOUBLE() antlr.TerminalNode { + return s.GetToken(MySqlParserDOUBLE, 0) +} + +func (s *DimensionDataTypeContext) PRECISION() antlr.TerminalNode { + return s.GetToken(MySqlParserPRECISION, 0) +} + +func (s *DimensionDataTypeContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(MySqlParserDECIMAL, 0) +} + +func (s *DimensionDataTypeContext) DEC() antlr.TerminalNode { + return s.GetToken(MySqlParserDEC, 0) +} + +func (s *DimensionDataTypeContext) FIXED() antlr.TerminalNode { + return s.GetToken(MySqlParserFIXED, 0) +} + +func (s *DimensionDataTypeContext) NUMERIC() antlr.TerminalNode { + return s.GetToken(MySqlParserNUMERIC, 0) +} + +func (s *DimensionDataTypeContext) FLOAT() antlr.TerminalNode { + return s.GetToken(MySqlParserFLOAT, 0) +} + +func (s *DimensionDataTypeContext) FLOAT4() antlr.TerminalNode { + return s.GetToken(MySqlParserFLOAT4, 0) +} + +func (s *DimensionDataTypeContext) FLOAT8() antlr.TerminalNode { + return s.GetToken(MySqlParserFLOAT8, 0) +} + +func (s *DimensionDataTypeContext) LengthTwoOptionalDimension() ILengthTwoOptionalDimensionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILengthTwoOptionalDimensionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILengthTwoOptionalDimensionContext) +} + +func (s *DimensionDataTypeContext) BIT() antlr.TerminalNode { + return s.GetToken(MySqlParserBIT, 0) +} + +func (s *DimensionDataTypeContext) TIME() antlr.TerminalNode { + return s.GetToken(MySqlParserTIME, 0) +} + +func (s *DimensionDataTypeContext) TIMESTAMP() antlr.TerminalNode { + return s.GetToken(MySqlParserTIMESTAMP, 0) +} + +func (s *DimensionDataTypeContext) DATETIME() antlr.TerminalNode { + return s.GetToken(MySqlParserDATETIME, 0) +} + +func (s *DimensionDataTypeContext) BINARY() antlr.TerminalNode { + return s.GetToken(MySqlParserBINARY, 0) +} + +func (s *DimensionDataTypeContext) VARBINARY() antlr.TerminalNode { + return s.GetToken(MySqlParserVARBINARY, 0) +} + +func (s *DimensionDataTypeContext) BLOB() antlr.TerminalNode { + return s.GetToken(MySqlParserBLOB, 0) +} + +func (s *DimensionDataTypeContext) YEAR() antlr.TerminalNode { + return s.GetToken(MySqlParserYEAR, 0) +} + +func (s *DimensionDataTypeContext) VECTOR() antlr.TerminalNode { + return s.GetToken(MySqlParserVECTOR, 0) +} + +func (s *DimensionDataTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterDimensionDataType(s) + } +} + +func (s *DimensionDataTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitDimensionDataType(s) + } +} + +type StringDataTypeContext struct { + DataTypeContext + typeName antlr.Token +} + +func NewStringDataTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StringDataTypeContext { + var p = new(StringDataTypeContext) + + InitEmptyDataTypeContext(&p.DataTypeContext) + p.parser = parser + p.CopyAll(ctx.(*DataTypeContext)) + + return p +} + +func (s *StringDataTypeContext) GetTypeName() antlr.Token { return s.typeName } + +func (s *StringDataTypeContext) SetTypeName(v antlr.Token) { s.typeName = v } + +func (s *StringDataTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *StringDataTypeContext) CHAR() antlr.TerminalNode { + return s.GetToken(MySqlParserCHAR, 0) +} + +func (s *StringDataTypeContext) CHARACTER() antlr.TerminalNode { + return s.GetToken(MySqlParserCHARACTER, 0) +} + +func (s *StringDataTypeContext) VARCHAR() antlr.TerminalNode { + return s.GetToken(MySqlParserVARCHAR, 0) +} + +func (s *StringDataTypeContext) TINYTEXT() antlr.TerminalNode { + return s.GetToken(MySqlParserTINYTEXT, 0) +} + +func (s *StringDataTypeContext) TEXT() antlr.TerminalNode { + return s.GetToken(MySqlParserTEXT, 0) +} + +func (s *StringDataTypeContext) MEDIUMTEXT() antlr.TerminalNode { + return s.GetToken(MySqlParserMEDIUMTEXT, 0) +} + +func (s *StringDataTypeContext) LONGTEXT() antlr.TerminalNode { + return s.GetToken(MySqlParserLONGTEXT, 0) +} + +func (s *StringDataTypeContext) NCHAR() antlr.TerminalNode { + return s.GetToken(MySqlParserNCHAR, 0) +} + +func (s *StringDataTypeContext) NVARCHAR() antlr.TerminalNode { + return s.GetToken(MySqlParserNVARCHAR, 0) +} + +func (s *StringDataTypeContext) LONG() antlr.TerminalNode { + return s.GetToken(MySqlParserLONG, 0) +} + +func (s *StringDataTypeContext) VARYING() antlr.TerminalNode { + return s.GetToken(MySqlParserVARYING, 0) +} + +func (s *StringDataTypeContext) LengthOneDimension() ILengthOneDimensionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILengthOneDimensionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILengthOneDimensionContext) +} + +func (s *StringDataTypeContext) AllBINARY() []antlr.TerminalNode { + return s.GetTokens(MySqlParserBINARY) +} + +func (s *StringDataTypeContext) BINARY(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserBINARY, i) +} + +func (s *StringDataTypeContext) CharSet() ICharSetContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICharSetContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICharSetContext) +} + +func (s *StringDataTypeContext) CharsetName() ICharsetNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICharsetNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICharsetNameContext) +} + +func (s *StringDataTypeContext) COLLATE() antlr.TerminalNode { + return s.GetToken(MySqlParserCOLLATE, 0) +} + +func (s *StringDataTypeContext) CollationName() ICollationNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICollationNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICollationNameContext) +} + +func (s *StringDataTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterStringDataType(s) + } +} + +func (s *StringDataTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitStringDataType(s) + } +} + +type LongVarcharDataTypeContext struct { + DataTypeContext + typeName antlr.Token +} + +func NewLongVarcharDataTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LongVarcharDataTypeContext { + var p = new(LongVarcharDataTypeContext) + + InitEmptyDataTypeContext(&p.DataTypeContext) + p.parser = parser + p.CopyAll(ctx.(*DataTypeContext)) + + return p +} + +func (s *LongVarcharDataTypeContext) GetTypeName() antlr.Token { return s.typeName } + +func (s *LongVarcharDataTypeContext) SetTypeName(v antlr.Token) { s.typeName = v } + +func (s *LongVarcharDataTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LongVarcharDataTypeContext) LONG() antlr.TerminalNode { + return s.GetToken(MySqlParserLONG, 0) +} + +func (s *LongVarcharDataTypeContext) VARCHAR() antlr.TerminalNode { + return s.GetToken(MySqlParserVARCHAR, 0) +} + +func (s *LongVarcharDataTypeContext) BINARY() antlr.TerminalNode { + return s.GetToken(MySqlParserBINARY, 0) +} + +func (s *LongVarcharDataTypeContext) CharSet() ICharSetContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICharSetContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICharSetContext) +} + +func (s *LongVarcharDataTypeContext) CharsetName() ICharsetNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICharsetNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICharsetNameContext) +} + +func (s *LongVarcharDataTypeContext) COLLATE() antlr.TerminalNode { + return s.GetToken(MySqlParserCOLLATE, 0) +} + +func (s *LongVarcharDataTypeContext) CollationName() ICollationNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICollationNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICollationNameContext) +} + +func (s *LongVarcharDataTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterLongVarcharDataType(s) + } +} + +func (s *LongVarcharDataTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitLongVarcharDataType(s) + } +} + +type NationalStringDataTypeContext struct { + DataTypeContext + typeName antlr.Token +} + +func NewNationalStringDataTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NationalStringDataTypeContext { + var p = new(NationalStringDataTypeContext) + + InitEmptyDataTypeContext(&p.DataTypeContext) + p.parser = parser + p.CopyAll(ctx.(*DataTypeContext)) + + return p +} + +func (s *NationalStringDataTypeContext) GetTypeName() antlr.Token { return s.typeName } + +func (s *NationalStringDataTypeContext) SetTypeName(v antlr.Token) { s.typeName = v } + +func (s *NationalStringDataTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *NationalStringDataTypeContext) NATIONAL() antlr.TerminalNode { + return s.GetToken(MySqlParserNATIONAL, 0) +} + +func (s *NationalStringDataTypeContext) VARCHAR() antlr.TerminalNode { + return s.GetToken(MySqlParserVARCHAR, 0) +} + +func (s *NationalStringDataTypeContext) CHARACTER() antlr.TerminalNode { + return s.GetToken(MySqlParserCHARACTER, 0) +} + +func (s *NationalStringDataTypeContext) CHAR() antlr.TerminalNode { + return s.GetToken(MySqlParserCHAR, 0) +} + +func (s *NationalStringDataTypeContext) LengthOneDimension() ILengthOneDimensionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILengthOneDimensionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILengthOneDimensionContext) +} + +func (s *NationalStringDataTypeContext) BINARY() antlr.TerminalNode { + return s.GetToken(MySqlParserBINARY, 0) +} + +func (s *NationalStringDataTypeContext) NCHAR() antlr.TerminalNode { + return s.GetToken(MySqlParserNCHAR, 0) +} + +func (s *NationalStringDataTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterNationalStringDataType(s) + } +} + +func (s *NationalStringDataTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitNationalStringDataType(s) + } +} + +type SimpleDataTypeContext struct { + DataTypeContext + typeName antlr.Token +} + +func NewSimpleDataTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SimpleDataTypeContext { + var p = new(SimpleDataTypeContext) + + InitEmptyDataTypeContext(&p.DataTypeContext) + p.parser = parser + p.CopyAll(ctx.(*DataTypeContext)) + + return p +} + +func (s *SimpleDataTypeContext) GetTypeName() antlr.Token { return s.typeName } + +func (s *SimpleDataTypeContext) SetTypeName(v antlr.Token) { s.typeName = v } + +func (s *SimpleDataTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SimpleDataTypeContext) DATE() antlr.TerminalNode { + return s.GetToken(MySqlParserDATE, 0) +} + +func (s *SimpleDataTypeContext) TINYBLOB() antlr.TerminalNode { + return s.GetToken(MySqlParserTINYBLOB, 0) +} + +func (s *SimpleDataTypeContext) MEDIUMBLOB() antlr.TerminalNode { + return s.GetToken(MySqlParserMEDIUMBLOB, 0) +} + +func (s *SimpleDataTypeContext) LONGBLOB() antlr.TerminalNode { + return s.GetToken(MySqlParserLONGBLOB, 0) +} + +func (s *SimpleDataTypeContext) BOOL() antlr.TerminalNode { + return s.GetToken(MySqlParserBOOL, 0) +} + +func (s *SimpleDataTypeContext) BOOLEAN() antlr.TerminalNode { + return s.GetToken(MySqlParserBOOLEAN, 0) +} + +func (s *SimpleDataTypeContext) SERIAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSERIAL, 0) +} + +func (s *SimpleDataTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSimpleDataType(s) + } +} + +func (s *SimpleDataTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSimpleDataType(s) + } +} + +func (p *MySqlParser) DataType() (localctx IDataTypeContext) { + localctx = NewDataTypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 604, MySqlParserRULE_dataType) + var _la int + + var _alt int + + p.SetState(6617) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 989, p.GetParserRuleContext()) { + case 1: + localctx = NewStringDataTypeContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6491) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*StringDataTypeContext).typeName = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserCHARACTER || ((int64((_la-222)) & ^0x3f) == 0 && ((int64(1)<<(_la-222))&31239) != 0) || _la == MySqlParserNCHAR) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*StringDataTypeContext).typeName = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(6493) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserVARYING { + { + p.SetState(6492) + p.Match(MySqlParserVARYING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(6496) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 962, p.GetParserRuleContext()) == 1 { + { + p.SetState(6495) + p.LengthOneDimension() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6499) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 963, p.GetParserRuleContext()) == 1 { + { + p.SetState(6498) + p.Match(MySqlParserBINARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6504) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 964, p.GetParserRuleContext()) == 1 { + { + p.SetState(6501) + p.CharSet() + } + { + p.SetState(6502) + p.CharsetName() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6509) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 965, p.GetParserRuleContext()) == 1 { + { + p.SetState(6506) + p.Match(MySqlParserCOLLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6507) + p.CollationName() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 965, p.GetParserRuleContext()) == 2 { + { + p.SetState(6508) + p.Match(MySqlParserBINARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + localctx = NewNationalVaryingStringDataTypeContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6511) + p.Match(MySqlParserNATIONAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6512) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*NationalVaryingStringDataTypeContext).typeName = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserCHARACTER || _la == MySqlParserCHAR) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*NationalVaryingStringDataTypeContext).typeName = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(6513) + p.Match(MySqlParserVARYING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6515) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 966, p.GetParserRuleContext()) == 1 { + { + p.SetState(6514) + p.LengthOneDimension() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6518) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 967, p.GetParserRuleContext()) == 1 { + { + p.SetState(6517) + p.Match(MySqlParserBINARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 3: + localctx = NewNationalStringDataTypeContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6520) + p.Match(MySqlParserNATIONAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6521) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*NationalStringDataTypeContext).typeName = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserCHARACTER || _la == MySqlParserCHAR || _la == MySqlParserVARCHAR) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*NationalStringDataTypeContext).typeName = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(6523) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 968, p.GetParserRuleContext()) == 1 { + { + p.SetState(6522) + p.LengthOneDimension() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6526) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 969, p.GetParserRuleContext()) == 1 { + { + p.SetState(6525) + p.Match(MySqlParserBINARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 4: + localctx = NewNationalStringDataTypeContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(6528) + p.Match(MySqlParserNCHAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6529) + + var _m = p.Match(MySqlParserVARCHAR) + + localctx.(*NationalStringDataTypeContext).typeName = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6531) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 970, p.GetParserRuleContext()) == 1 { + { + p.SetState(6530) + p.LengthOneDimension() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6534) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 971, p.GetParserRuleContext()) == 1 { + { + p.SetState(6533) + p.Match(MySqlParserBINARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 5: + localctx = NewDimensionDataTypeContext(p, localctx) + p.EnterOuterAlt(localctx, 5) + { + p.SetState(6536) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*DimensionDataTypeContext).typeName = _lt + + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-196)) & ^0x3f) == 0 && ((int64(1)<<(_la-196))&4095) != 0) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*DimensionDataTypeContext).typeName = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(6538) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 972, p.GetParserRuleContext()) == 1 { + { + p.SetState(6537) + p.LengthOneDimension() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6543) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 973, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(6540) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserUNSIGNED || _la == MySqlParserZEROFILL || _la == MySqlParserSIGNED) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(6545) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 973, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 6: + localctx = NewDimensionDataTypeContext(p, localctx) + p.EnterOuterAlt(localctx, 6) + { + p.SetState(6546) + + var _m = p.Match(MySqlParserREAL) + + localctx.(*DimensionDataTypeContext).typeName = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6548) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 974, p.GetParserRuleContext()) == 1 { + { + p.SetState(6547) + p.LengthTwoDimension() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6553) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 975, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(6550) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserUNSIGNED || _la == MySqlParserZEROFILL || _la == MySqlParserSIGNED) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(6555) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 975, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 7: + localctx = NewDimensionDataTypeContext(p, localctx) + p.EnterOuterAlt(localctx, 7) + { + p.SetState(6556) + + var _m = p.Match(MySqlParserDOUBLE) + + localctx.(*DimensionDataTypeContext).typeName = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6558) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserPRECISION { + { + p.SetState(6557) + p.Match(MySqlParserPRECISION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(6561) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 977, p.GetParserRuleContext()) == 1 { + { + p.SetState(6560) + p.LengthTwoDimension() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6566) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 978, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(6563) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserUNSIGNED || _la == MySqlParserZEROFILL || _la == MySqlParserSIGNED) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(6568) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 978, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 8: + localctx = NewDimensionDataTypeContext(p, localctx) + p.EnterOuterAlt(localctx, 8) + { + p.SetState(6569) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*DimensionDataTypeContext).typeName = _lt + + _la = p.GetTokenStream().LA(1) + + if !(((int64((_la-211)) & ^0x3f) == 0 && ((int64(1)<<(_la-211))&63) != 0) || _la == MySqlParserFIXED) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*DimensionDataTypeContext).typeName = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(6571) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 979, p.GetParserRuleContext()) == 1 { + { + p.SetState(6570) + p.LengthTwoOptionalDimension() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6576) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 980, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(6573) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserUNSIGNED || _la == MySqlParserZEROFILL || _la == MySqlParserSIGNED) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(6578) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 980, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 9: + localctx = NewSimpleDataTypeContext(p, localctx) + p.EnterOuterAlt(localctx, 9) + { + p.SetState(6579) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*SimpleDataTypeContext).typeName = _lt + + _la = p.GetTokenStream().LA(1) + + if !(((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&4237313) != 0) || _la == MySqlParserBOOL || _la == MySqlParserBOOLEAN) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*SimpleDataTypeContext).typeName = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 10: + localctx = NewDimensionDataTypeContext(p, localctx) + p.EnterOuterAlt(localctx, 10) + { + p.SetState(6580) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*DimensionDataTypeContext).typeName = _lt + + _la = p.GetTokenStream().LA(1) + + if !(((int64((_la-218)) & ^0x3f) == 0 && ((int64(1)<<(_la-218))&4197135) != 0) || _la == MySqlParserBIT) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*DimensionDataTypeContext).typeName = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(6582) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 981, p.GetParserRuleContext()) == 1 { + { + p.SetState(6581) + p.LengthOneDimension() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 11: + localctx = NewCollectionDataTypeContext(p, localctx) + p.EnterOuterAlt(localctx, 11) + { + p.SetState(6584) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*CollectionDataTypeContext).typeName = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserSET || _la == MySqlParserENUM) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*CollectionDataTypeContext).typeName = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(6585) + p.CollectionOptions() + } + p.SetState(6587) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 982, p.GetParserRuleContext()) == 1 { + { + p.SetState(6586) + p.Match(MySqlParserBINARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6592) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 983, p.GetParserRuleContext()) == 1 { + { + p.SetState(6589) + p.CharSet() + } + { + p.SetState(6590) + p.CharsetName() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 12: + localctx = NewSpatialDataTypeContext(p, localctx) + p.EnterOuterAlt(localctx, 12) + { + p.SetState(6594) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*SpatialDataTypeContext).typeName = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserJSON || ((int64((_la-804)) & ^0x3f) == 0 && ((int64(1)<<(_la-804))&511) != 0)) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*SpatialDataTypeContext).typeName = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(6597) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 984, p.GetParserRuleContext()) == 1 { + { + p.SetState(6595) + p.Match(MySqlParserSRID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6596) + p.DecimalLiteral() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 13: + localctx = NewLongVarcharDataTypeContext(p, localctx) + p.EnterOuterAlt(localctx, 13) + { + p.SetState(6599) + + var _m = p.Match(MySqlParserLONG) + + localctx.(*LongVarcharDataTypeContext).typeName = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6601) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserVARCHAR { + { + p.SetState(6600) + p.Match(MySqlParserVARCHAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(6604) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 986, p.GetParserRuleContext()) == 1 { + { + p.SetState(6603) + p.Match(MySqlParserBINARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6609) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 987, p.GetParserRuleContext()) == 1 { + { + p.SetState(6606) + p.CharSet() + } + { + p.SetState(6607) + p.CharsetName() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6613) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 988, p.GetParserRuleContext()) == 1 { + { + p.SetState(6611) + p.Match(MySqlParserCOLLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6612) + p.CollationName() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 14: + localctx = NewLongVarbinaryDataTypeContext(p, localctx) + p.EnterOuterAlt(localctx, 14) + { + p.SetState(6615) + p.Match(MySqlParserLONG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6616) + p.Match(MySqlParserVARBINARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICollectionOptionsContext is an interface to support dynamic dispatch. +type ICollectionOptionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + AllSTRING_LITERAL() []antlr.TerminalNode + STRING_LITERAL(i int) antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsCollectionOptionsContext differentiates from other interfaces. + IsCollectionOptionsContext() +} + +type CollectionOptionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCollectionOptionsContext() *CollectionOptionsContext { + var p = new(CollectionOptionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_collectionOptions + return p +} + +func InitEmptyCollectionOptionsContext(p *CollectionOptionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_collectionOptions +} + +func (*CollectionOptionsContext) IsCollectionOptionsContext() {} + +func NewCollectionOptionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollectionOptionsContext { + var p = new(CollectionOptionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_collectionOptions + + return p +} + +func (s *CollectionOptionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *CollectionOptionsContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *CollectionOptionsContext) AllSTRING_LITERAL() []antlr.TerminalNode { + return s.GetTokens(MySqlParserSTRING_LITERAL) +} + +func (s *CollectionOptionsContext) STRING_LITERAL(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, i) +} + +func (s *CollectionOptionsContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *CollectionOptionsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *CollectionOptionsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *CollectionOptionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CollectionOptionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CollectionOptionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCollectionOptions(s) + } +} + +func (s *CollectionOptionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCollectionOptions(s) + } +} + +func (p *MySqlParser) CollectionOptions() (localctx ICollectionOptionsContext) { + localctx = NewCollectionOptionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 606, MySqlParserRULE_collectionOptions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6619) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6620) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6625) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(6621) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6622) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(6627) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6628) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IConvertedDataTypeContext is an interface to support dynamic dispatch. +type IConvertedDataTypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetTypeName returns the typeName token. + GetTypeName() antlr.Token + + // SetTypeName sets the typeName token. + SetTypeName(antlr.Token) + + // Getter signatures + CHAR() antlr.TerminalNode + SIGNED() antlr.TerminalNode + UNSIGNED() antlr.TerminalNode + ARRAY() antlr.TerminalNode + BINARY() antlr.TerminalNode + NCHAR() antlr.TerminalNode + FLOAT() antlr.TerminalNode + DATE() antlr.TerminalNode + DATETIME() antlr.TerminalNode + TIME() antlr.TerminalNode + YEAR() antlr.TerminalNode + JSON() antlr.TerminalNode + INT() antlr.TerminalNode + INTEGER() antlr.TerminalNode + DOUBLE() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + DEC() antlr.TerminalNode + LengthOneDimension() ILengthOneDimensionContext + CharSet() ICharSetContext + CharsetName() ICharsetNameContext + LengthTwoOptionalDimension() ILengthTwoOptionalDimensionContext + + // IsConvertedDataTypeContext differentiates from other interfaces. + IsConvertedDataTypeContext() +} + +type ConvertedDataTypeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + typeName antlr.Token +} + +func NewEmptyConvertedDataTypeContext() *ConvertedDataTypeContext { + var p = new(ConvertedDataTypeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_convertedDataType + return p +} + +func InitEmptyConvertedDataTypeContext(p *ConvertedDataTypeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_convertedDataType +} + +func (*ConvertedDataTypeContext) IsConvertedDataTypeContext() {} + +func NewConvertedDataTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConvertedDataTypeContext { + var p = new(ConvertedDataTypeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_convertedDataType + + return p +} + +func (s *ConvertedDataTypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *ConvertedDataTypeContext) GetTypeName() antlr.Token { return s.typeName } + +func (s *ConvertedDataTypeContext) SetTypeName(v antlr.Token) { s.typeName = v } + +func (s *ConvertedDataTypeContext) CHAR() antlr.TerminalNode { + return s.GetToken(MySqlParserCHAR, 0) +} + +func (s *ConvertedDataTypeContext) SIGNED() antlr.TerminalNode { + return s.GetToken(MySqlParserSIGNED, 0) +} + +func (s *ConvertedDataTypeContext) UNSIGNED() antlr.TerminalNode { + return s.GetToken(MySqlParserUNSIGNED, 0) +} + +func (s *ConvertedDataTypeContext) ARRAY() antlr.TerminalNode { + return s.GetToken(MySqlParserARRAY, 0) +} + +func (s *ConvertedDataTypeContext) BINARY() antlr.TerminalNode { + return s.GetToken(MySqlParserBINARY, 0) +} + +func (s *ConvertedDataTypeContext) NCHAR() antlr.TerminalNode { + return s.GetToken(MySqlParserNCHAR, 0) +} + +func (s *ConvertedDataTypeContext) FLOAT() antlr.TerminalNode { + return s.GetToken(MySqlParserFLOAT, 0) +} + +func (s *ConvertedDataTypeContext) DATE() antlr.TerminalNode { + return s.GetToken(MySqlParserDATE, 0) +} + +func (s *ConvertedDataTypeContext) DATETIME() antlr.TerminalNode { + return s.GetToken(MySqlParserDATETIME, 0) +} + +func (s *ConvertedDataTypeContext) TIME() antlr.TerminalNode { + return s.GetToken(MySqlParserTIME, 0) +} + +func (s *ConvertedDataTypeContext) YEAR() antlr.TerminalNode { + return s.GetToken(MySqlParserYEAR, 0) +} + +func (s *ConvertedDataTypeContext) JSON() antlr.TerminalNode { + return s.GetToken(MySqlParserJSON, 0) +} + +func (s *ConvertedDataTypeContext) INT() antlr.TerminalNode { + return s.GetToken(MySqlParserINT, 0) +} + +func (s *ConvertedDataTypeContext) INTEGER() antlr.TerminalNode { + return s.GetToken(MySqlParserINTEGER, 0) +} + +func (s *ConvertedDataTypeContext) DOUBLE() antlr.TerminalNode { + return s.GetToken(MySqlParserDOUBLE, 0) +} + +func (s *ConvertedDataTypeContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(MySqlParserDECIMAL, 0) +} + +func (s *ConvertedDataTypeContext) DEC() antlr.TerminalNode { + return s.GetToken(MySqlParserDEC, 0) +} + +func (s *ConvertedDataTypeContext) LengthOneDimension() ILengthOneDimensionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILengthOneDimensionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILengthOneDimensionContext) +} + +func (s *ConvertedDataTypeContext) CharSet() ICharSetContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICharSetContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICharSetContext) +} + +func (s *ConvertedDataTypeContext) CharsetName() ICharsetNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICharsetNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICharsetNameContext) +} + +func (s *ConvertedDataTypeContext) LengthTwoOptionalDimension() ILengthTwoOptionalDimensionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILengthTwoOptionalDimensionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILengthTwoOptionalDimensionContext) +} + +func (s *ConvertedDataTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ConvertedDataTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ConvertedDataTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterConvertedDataType(s) + } +} + +func (s *ConvertedDataTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitConvertedDataType(s) + } +} + +func (p *MySqlParser) ConvertedDataType() (localctx IConvertedDataTypeContext) { + localctx = NewConvertedDataTypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 608, MySqlParserRULE_convertedDataType) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(6652) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserFLOAT, MySqlParserBINARY, MySqlParserNCHAR: + { + p.SetState(6630) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*ConvertedDataTypeContext).typeName = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserFLOAT || _la == MySqlParserBINARY || _la == MySqlParserNCHAR) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*ConvertedDataTypeContext).typeName = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(6632) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserLR_BRACKET { + { + p.SetState(6631) + p.LengthOneDimension() + } + + } + + case MySqlParserCHAR: + { + p.SetState(6634) + + var _m = p.Match(MySqlParserCHAR) + + localctx.(*ConvertedDataTypeContext).typeName = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6636) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserLR_BRACKET { + { + p.SetState(6635) + p.LengthOneDimension() + } + + } + p.SetState(6641) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserCHARACTER || _la == MySqlParserCHAR || _la == MySqlParserCHARSET { + { + p.SetState(6638) + p.CharSet() + } + { + p.SetState(6639) + p.CharsetName() + } + + } + + case MySqlParserINT, MySqlParserINTEGER, MySqlParserDOUBLE, MySqlParserDATE, MySqlParserTIME, MySqlParserDATETIME, MySqlParserYEAR, MySqlParserJSON: + { + p.SetState(6643) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*ConvertedDataTypeContext).typeName = _lt + + _la = p.GetTokenStream().LA(1) + + if !(((int64((_la-200)) & ^0x3f) == 0 && ((int64(1)<<(_la-200))&3539521) != 0) || _la == MySqlParserJSON) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*ConvertedDataTypeContext).typeName = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case MySqlParserDECIMAL, MySqlParserDEC: + { + p.SetState(6644) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*ConvertedDataTypeContext).typeName = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserDECIMAL || _la == MySqlParserDEC) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*ConvertedDataTypeContext).typeName = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(6646) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserLR_BRACKET { + { + p.SetState(6645) + p.LengthTwoOptionalDimension() + } + + } + + case MySqlParserUNSIGNED, MySqlParserSIGNED: + { + p.SetState(6648) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserUNSIGNED || _la == MySqlParserSIGNED) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(6650) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserINT || _la == MySqlParserINTEGER { + { + p.SetState(6649) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserINT || _la == MySqlParserINTEGER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(6655) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserARRAY { + { + p.SetState(6654) + p.Match(MySqlParserARRAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILengthOneDimensionContext is an interface to support dynamic dispatch. +type ILengthOneDimensionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + DecimalLiteral() IDecimalLiteralContext + RR_BRACKET() antlr.TerminalNode + + // IsLengthOneDimensionContext differentiates from other interfaces. + IsLengthOneDimensionContext() +} + +type LengthOneDimensionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLengthOneDimensionContext() *LengthOneDimensionContext { + var p = new(LengthOneDimensionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_lengthOneDimension + return p +} + +func InitEmptyLengthOneDimensionContext(p *LengthOneDimensionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_lengthOneDimension +} + +func (*LengthOneDimensionContext) IsLengthOneDimensionContext() {} + +func NewLengthOneDimensionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LengthOneDimensionContext { + var p = new(LengthOneDimensionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_lengthOneDimension + + return p +} + +func (s *LengthOneDimensionContext) GetParser() antlr.Parser { return s.parser } + +func (s *LengthOneDimensionContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *LengthOneDimensionContext) DecimalLiteral() IDecimalLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *LengthOneDimensionContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *LengthOneDimensionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LengthOneDimensionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *LengthOneDimensionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterLengthOneDimension(s) + } +} + +func (s *LengthOneDimensionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitLengthOneDimension(s) + } +} + +func (p *MySqlParser) LengthOneDimension() (localctx ILengthOneDimensionContext) { + localctx = NewLengthOneDimensionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 610, MySqlParserRULE_lengthOneDimension) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6657) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6658) + p.DecimalLiteral() + } + { + p.SetState(6659) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILengthTwoDimensionContext is an interface to support dynamic dispatch. +type ILengthTwoDimensionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + AllDecimalLiteral() []IDecimalLiteralContext + DecimalLiteral(i int) IDecimalLiteralContext + COMMA() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + + // IsLengthTwoDimensionContext differentiates from other interfaces. + IsLengthTwoDimensionContext() +} + +type LengthTwoDimensionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLengthTwoDimensionContext() *LengthTwoDimensionContext { + var p = new(LengthTwoDimensionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_lengthTwoDimension + return p +} + +func InitEmptyLengthTwoDimensionContext(p *LengthTwoDimensionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_lengthTwoDimension +} + +func (*LengthTwoDimensionContext) IsLengthTwoDimensionContext() {} + +func NewLengthTwoDimensionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LengthTwoDimensionContext { + var p = new(LengthTwoDimensionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_lengthTwoDimension + + return p +} + +func (s *LengthTwoDimensionContext) GetParser() antlr.Parser { return s.parser } + +func (s *LengthTwoDimensionContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *LengthTwoDimensionContext) AllDecimalLiteral() []IDecimalLiteralContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDecimalLiteralContext); ok { + len++ + } + } + + tst := make([]IDecimalLiteralContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDecimalLiteralContext); ok { + tst[i] = t.(IDecimalLiteralContext) + i++ + } + } + + return tst +} + +func (s *LengthTwoDimensionContext) DecimalLiteral(i int) IDecimalLiteralContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *LengthTwoDimensionContext) COMMA() antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, 0) +} + +func (s *LengthTwoDimensionContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *LengthTwoDimensionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LengthTwoDimensionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *LengthTwoDimensionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterLengthTwoDimension(s) + } +} + +func (s *LengthTwoDimensionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitLengthTwoDimension(s) + } +} + +func (p *MySqlParser) LengthTwoDimension() (localctx ILengthTwoDimensionContext) { + localctx = NewLengthTwoDimensionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 612, MySqlParserRULE_lengthTwoDimension) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6661) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6662) + p.DecimalLiteral() + } + { + p.SetState(6663) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6664) + p.DecimalLiteral() + } + { + p.SetState(6665) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILengthTwoOptionalDimensionContext is an interface to support dynamic dispatch. +type ILengthTwoOptionalDimensionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + AllDecimalLiteral() []IDecimalLiteralContext + DecimalLiteral(i int) IDecimalLiteralContext + RR_BRACKET() antlr.TerminalNode + COMMA() antlr.TerminalNode + + // IsLengthTwoOptionalDimensionContext differentiates from other interfaces. + IsLengthTwoOptionalDimensionContext() +} + +type LengthTwoOptionalDimensionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLengthTwoOptionalDimensionContext() *LengthTwoOptionalDimensionContext { + var p = new(LengthTwoOptionalDimensionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_lengthTwoOptionalDimension + return p +} + +func InitEmptyLengthTwoOptionalDimensionContext(p *LengthTwoOptionalDimensionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_lengthTwoOptionalDimension +} + +func (*LengthTwoOptionalDimensionContext) IsLengthTwoOptionalDimensionContext() {} + +func NewLengthTwoOptionalDimensionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LengthTwoOptionalDimensionContext { + var p = new(LengthTwoOptionalDimensionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_lengthTwoOptionalDimension + + return p +} + +func (s *LengthTwoOptionalDimensionContext) GetParser() antlr.Parser { return s.parser } + +func (s *LengthTwoOptionalDimensionContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *LengthTwoOptionalDimensionContext) AllDecimalLiteral() []IDecimalLiteralContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDecimalLiteralContext); ok { + len++ + } + } + + tst := make([]IDecimalLiteralContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDecimalLiteralContext); ok { + tst[i] = t.(IDecimalLiteralContext) + i++ + } + } + + return tst +} + +func (s *LengthTwoOptionalDimensionContext) DecimalLiteral(i int) IDecimalLiteralContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *LengthTwoOptionalDimensionContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *LengthTwoOptionalDimensionContext) COMMA() antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, 0) +} + +func (s *LengthTwoOptionalDimensionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LengthTwoOptionalDimensionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *LengthTwoOptionalDimensionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterLengthTwoOptionalDimension(s) + } +} + +func (s *LengthTwoOptionalDimensionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitLengthTwoOptionalDimension(s) + } +} + +func (p *MySqlParser) LengthTwoOptionalDimension() (localctx ILengthTwoOptionalDimensionContext) { + localctx = NewLengthTwoOptionalDimensionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 614, MySqlParserRULE_lengthTwoOptionalDimension) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6667) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6668) + p.DecimalLiteral() + } + p.SetState(6671) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserCOMMA { + { + p.SetState(6669) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6670) + p.DecimalLiteral() + } + + } + { + p.SetState(6673) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUidListContext is an interface to support dynamic dispatch. +type IUidListContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllUid() []IUidContext + Uid(i int) IUidContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsUidListContext differentiates from other interfaces. + IsUidListContext() +} + +type UidListContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUidListContext() *UidListContext { + var p = new(UidListContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_uidList + return p +} + +func InitEmptyUidListContext(p *UidListContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_uidList +} + +func (*UidListContext) IsUidListContext() {} + +func NewUidListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UidListContext { + var p = new(UidListContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_uidList + + return p +} + +func (s *UidListContext) GetParser() antlr.Parser { return s.parser } + +func (s *UidListContext) AllUid() []IUidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUidContext); ok { + len++ + } + } + + tst := make([]IUidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUidContext); ok { + tst[i] = t.(IUidContext) + i++ + } + } + + return tst +} + +func (s *UidListContext) Uid(i int) IUidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *UidListContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *UidListContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *UidListContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UidListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *UidListContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterUidList(s) + } +} + +func (s *UidListContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitUidList(s) + } +} + +func (p *MySqlParser) UidList() (localctx IUidListContext) { + localctx = NewUidListContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 616, MySqlParserRULE_uidList) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6675) + p.Uid() + } + p.SetState(6680) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 999, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(6676) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6677) + p.Uid() + } + + } + p.SetState(6682) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 999, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFullColumnNameListContext is an interface to support dynamic dispatch. +type IFullColumnNameListContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllFullColumnName() []IFullColumnNameContext + FullColumnName(i int) IFullColumnNameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsFullColumnNameListContext differentiates from other interfaces. + IsFullColumnNameListContext() +} + +type FullColumnNameListContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFullColumnNameListContext() *FullColumnNameListContext { + var p = new(FullColumnNameListContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_fullColumnNameList + return p +} + +func InitEmptyFullColumnNameListContext(p *FullColumnNameListContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_fullColumnNameList +} + +func (*FullColumnNameListContext) IsFullColumnNameListContext() {} + +func NewFullColumnNameListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FullColumnNameListContext { + var p = new(FullColumnNameListContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_fullColumnNameList + + return p +} + +func (s *FullColumnNameListContext) GetParser() antlr.Parser { return s.parser } + +func (s *FullColumnNameListContext) AllFullColumnName() []IFullColumnNameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFullColumnNameContext); ok { + len++ + } + } + + tst := make([]IFullColumnNameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFullColumnNameContext); ok { + tst[i] = t.(IFullColumnNameContext) + i++ + } + } + + return tst +} + +func (s *FullColumnNameListContext) FullColumnName(i int) IFullColumnNameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFullColumnNameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFullColumnNameContext) +} + +func (s *FullColumnNameListContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *FullColumnNameListContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *FullColumnNameListContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FullColumnNameListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FullColumnNameListContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterFullColumnNameList(s) + } +} + +func (s *FullColumnNameListContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitFullColumnNameList(s) + } +} + +func (p *MySqlParser) FullColumnNameList() (localctx IFullColumnNameListContext) { + localctx = NewFullColumnNameListContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 618, MySqlParserRULE_fullColumnNameList) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6683) + p.FullColumnName() + } + p.SetState(6688) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(6684) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6685) + p.FullColumnName() + } + + p.SetState(6690) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITablesContext is an interface to support dynamic dispatch. +type ITablesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllTableName() []ITableNameContext + TableName(i int) ITableNameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsTablesContext differentiates from other interfaces. + IsTablesContext() +} + +type TablesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTablesContext() *TablesContext { + var p = new(TablesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_tables + return p +} + +func InitEmptyTablesContext(p *TablesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_tables +} + +func (*TablesContext) IsTablesContext() {} + +func NewTablesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TablesContext { + var p = new(TablesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_tables + + return p +} + +func (s *TablesContext) GetParser() antlr.Parser { return s.parser } + +func (s *TablesContext) AllTableName() []ITableNameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITableNameContext); ok { + len++ + } + } + + tst := make([]ITableNameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITableNameContext); ok { + tst[i] = t.(ITableNameContext) + i++ + } + } + + return tst +} + +func (s *TablesContext) TableName(i int) ITableNameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableNameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITableNameContext) +} + +func (s *TablesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *TablesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *TablesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TablesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TablesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTables(s) + } +} + +func (s *TablesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTables(s) + } +} + +func (p *MySqlParser) Tables() (localctx ITablesContext) { + localctx = NewTablesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 620, MySqlParserRULE_tables) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6691) + p.TableName() + } + p.SetState(6696) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1001, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(6692) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6693) + p.TableName() + } + + } + p.SetState(6698) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1001, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndexColumnNamesContext is an interface to support dynamic dispatch. +type IIndexColumnNamesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + AllIndexColumnName() []IIndexColumnNameContext + IndexColumnName(i int) IIndexColumnNameContext + RR_BRACKET() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsIndexColumnNamesContext differentiates from other interfaces. + IsIndexColumnNamesContext() +} + +type IndexColumnNamesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndexColumnNamesContext() *IndexColumnNamesContext { + var p = new(IndexColumnNamesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_indexColumnNames + return p +} + +func InitEmptyIndexColumnNamesContext(p *IndexColumnNamesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_indexColumnNames +} + +func (*IndexColumnNamesContext) IsIndexColumnNamesContext() {} + +func NewIndexColumnNamesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndexColumnNamesContext { + var p = new(IndexColumnNamesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_indexColumnNames + + return p +} + +func (s *IndexColumnNamesContext) GetParser() antlr.Parser { return s.parser } + +func (s *IndexColumnNamesContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *IndexColumnNamesContext) AllIndexColumnName() []IIndexColumnNameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIndexColumnNameContext); ok { + len++ + } + } + + tst := make([]IIndexColumnNameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIndexColumnNameContext); ok { + tst[i] = t.(IIndexColumnNameContext) + i++ + } + } + + return tst +} + +func (s *IndexColumnNamesContext) IndexColumnName(i int) IIndexColumnNameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexColumnNameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIndexColumnNameContext) +} + +func (s *IndexColumnNamesContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *IndexColumnNamesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *IndexColumnNamesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *IndexColumnNamesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IndexColumnNamesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IndexColumnNamesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterIndexColumnNames(s) + } +} + +func (s *IndexColumnNamesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitIndexColumnNames(s) + } +} + +func (p *MySqlParser) IndexColumnNames() (localctx IIndexColumnNamesContext) { + localctx = NewIndexColumnNamesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 622, MySqlParserRULE_indexColumnNames) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6699) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6700) + p.IndexColumnName() + } + p.SetState(6705) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(6701) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6702) + p.IndexColumnName() + } + + p.SetState(6707) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6708) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExpressionsContext is an interface to support dynamic dispatch. +type IExpressionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsExpressionsContext differentiates from other interfaces. + IsExpressionsContext() +} + +type ExpressionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExpressionsContext() *ExpressionsContext { + var p = new(ExpressionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_expressions + return p +} + +func InitEmptyExpressionsContext(p *ExpressionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_expressions +} + +func (*ExpressionsContext) IsExpressionsContext() {} + +func NewExpressionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionsContext { + var p = new(ExpressionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_expressions + + return p +} + +func (s *ExpressionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *ExpressionsContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *ExpressionsContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *ExpressionsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *ExpressionsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *ExpressionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ExpressionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ExpressionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterExpressions(s) + } +} + +func (s *ExpressionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitExpressions(s) + } +} + +func (p *MySqlParser) Expressions() (localctx IExpressionsContext) { + localctx = NewExpressionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 624, MySqlParserRULE_expressions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6710) + p.expression(0) + } + p.SetState(6715) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(6711) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6712) + p.expression(0) + } + + p.SetState(6717) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExpressionsWithDefaultsContext is an interface to support dynamic dispatch. +type IExpressionsWithDefaultsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllExpressionOrDefault() []IExpressionOrDefaultContext + ExpressionOrDefault(i int) IExpressionOrDefaultContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsExpressionsWithDefaultsContext differentiates from other interfaces. + IsExpressionsWithDefaultsContext() +} + +type ExpressionsWithDefaultsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExpressionsWithDefaultsContext() *ExpressionsWithDefaultsContext { + var p = new(ExpressionsWithDefaultsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_expressionsWithDefaults + return p +} + +func InitEmptyExpressionsWithDefaultsContext(p *ExpressionsWithDefaultsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_expressionsWithDefaults +} + +func (*ExpressionsWithDefaultsContext) IsExpressionsWithDefaultsContext() {} + +func NewExpressionsWithDefaultsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionsWithDefaultsContext { + var p = new(ExpressionsWithDefaultsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_expressionsWithDefaults + + return p +} + +func (s *ExpressionsWithDefaultsContext) GetParser() antlr.Parser { return s.parser } + +func (s *ExpressionsWithDefaultsContext) AllExpressionOrDefault() []IExpressionOrDefaultContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionOrDefaultContext); ok { + len++ + } + } + + tst := make([]IExpressionOrDefaultContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionOrDefaultContext); ok { + tst[i] = t.(IExpressionOrDefaultContext) + i++ + } + } + + return tst +} + +func (s *ExpressionsWithDefaultsContext) ExpressionOrDefault(i int) IExpressionOrDefaultContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionOrDefaultContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionOrDefaultContext) +} + +func (s *ExpressionsWithDefaultsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *ExpressionsWithDefaultsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *ExpressionsWithDefaultsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ExpressionsWithDefaultsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ExpressionsWithDefaultsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterExpressionsWithDefaults(s) + } +} + +func (s *ExpressionsWithDefaultsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitExpressionsWithDefaults(s) + } +} + +func (p *MySqlParser) ExpressionsWithDefaults() (localctx IExpressionsWithDefaultsContext) { + localctx = NewExpressionsWithDefaultsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 626, MySqlParserRULE_expressionsWithDefaults) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6718) + p.ExpressionOrDefault() + } + p.SetState(6723) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(6719) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6720) + p.ExpressionOrDefault() + } + + p.SetState(6725) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IConstantsContext is an interface to support dynamic dispatch. +type IConstantsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllConstant() []IConstantContext + Constant(i int) IConstantContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsConstantsContext differentiates from other interfaces. + IsConstantsContext() +} + +type ConstantsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConstantsContext() *ConstantsContext { + var p = new(ConstantsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_constants + return p +} + +func InitEmptyConstantsContext(p *ConstantsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_constants +} + +func (*ConstantsContext) IsConstantsContext() {} + +func NewConstantsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstantsContext { + var p = new(ConstantsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_constants + + return p +} + +func (s *ConstantsContext) GetParser() antlr.Parser { return s.parser } + +func (s *ConstantsContext) AllConstant() []IConstantContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IConstantContext); ok { + len++ + } + } + + tst := make([]IConstantContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IConstantContext); ok { + tst[i] = t.(IConstantContext) + i++ + } + } + + return tst +} + +func (s *ConstantsContext) Constant(i int) IConstantContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstantContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IConstantContext) +} + +func (s *ConstantsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *ConstantsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *ConstantsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ConstantsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ConstantsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterConstants(s) + } +} + +func (s *ConstantsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitConstants(s) + } +} + +func (p *MySqlParser) Constants() (localctx IConstantsContext) { + localctx = NewConstantsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 628, MySqlParserRULE_constants) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6726) + p.Constant() + } + p.SetState(6731) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(6727) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6728) + p.Constant() + } + + p.SetState(6733) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISimpleStringsContext is an interface to support dynamic dispatch. +type ISimpleStringsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllSTRING_LITERAL() []antlr.TerminalNode + STRING_LITERAL(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsSimpleStringsContext differentiates from other interfaces. + IsSimpleStringsContext() +} + +type SimpleStringsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySimpleStringsContext() *SimpleStringsContext { + var p = new(SimpleStringsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_simpleStrings + return p +} + +func InitEmptySimpleStringsContext(p *SimpleStringsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_simpleStrings +} + +func (*SimpleStringsContext) IsSimpleStringsContext() {} + +func NewSimpleStringsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SimpleStringsContext { + var p = new(SimpleStringsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_simpleStrings + + return p +} + +func (s *SimpleStringsContext) GetParser() antlr.Parser { return s.parser } + +func (s *SimpleStringsContext) AllSTRING_LITERAL() []antlr.TerminalNode { + return s.GetTokens(MySqlParserSTRING_LITERAL) +} + +func (s *SimpleStringsContext) STRING_LITERAL(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, i) +} + +func (s *SimpleStringsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *SimpleStringsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *SimpleStringsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SimpleStringsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SimpleStringsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSimpleStrings(s) + } +} + +func (s *SimpleStringsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSimpleStrings(s) + } +} + +func (p *MySqlParser) SimpleStrings() (localctx ISimpleStringsContext) { + localctx = NewSimpleStringsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 630, MySqlParserRULE_simpleStrings) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6734) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6739) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(6735) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6736) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(6741) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUserVariablesContext is an interface to support dynamic dispatch. +type IUserVariablesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllLOCAL_ID() []antlr.TerminalNode + LOCAL_ID(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsUserVariablesContext differentiates from other interfaces. + IsUserVariablesContext() +} + +type UserVariablesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUserVariablesContext() *UserVariablesContext { + var p = new(UserVariablesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_userVariables + return p +} + +func InitEmptyUserVariablesContext(p *UserVariablesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_userVariables +} + +func (*UserVariablesContext) IsUserVariablesContext() {} + +func NewUserVariablesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UserVariablesContext { + var p = new(UserVariablesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_userVariables + + return p +} + +func (s *UserVariablesContext) GetParser() antlr.Parser { return s.parser } + +func (s *UserVariablesContext) AllLOCAL_ID() []antlr.TerminalNode { + return s.GetTokens(MySqlParserLOCAL_ID) +} + +func (s *UserVariablesContext) LOCAL_ID(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserLOCAL_ID, i) +} + +func (s *UserVariablesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *UserVariablesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *UserVariablesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UserVariablesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *UserVariablesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterUserVariables(s) + } +} + +func (s *UserVariablesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitUserVariables(s) + } +} + +func (p *MySqlParser) UserVariables() (localctx IUserVariablesContext) { + localctx = NewUserVariablesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 632, MySqlParserRULE_userVariables) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6742) + p.Match(MySqlParserLOCAL_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6747) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(6743) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6744) + p.Match(MySqlParserLOCAL_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(6749) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDefaultValueContext is an interface to support dynamic dispatch. +type IDefaultValueContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NULL_LITERAL() antlr.TerminalNode + CAST() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + Expression() IExpressionContext + AS() antlr.TerminalNode + ConvertedDataType() IConvertedDataTypeContext + RR_BRACKET() antlr.TerminalNode + Constant() IConstantContext + UnaryOperator() IUnaryOperatorContext + AllCurrentTimestamp() []ICurrentTimestampContext + CurrentTimestamp(i int) ICurrentTimestampContext + ON() antlr.TerminalNode + UPDATE() antlr.TerminalNode + FullId() IFullIdContext + + // IsDefaultValueContext differentiates from other interfaces. + IsDefaultValueContext() +} + +type DefaultValueContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDefaultValueContext() *DefaultValueContext { + var p = new(DefaultValueContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_defaultValue + return p +} + +func InitEmptyDefaultValueContext(p *DefaultValueContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_defaultValue +} + +func (*DefaultValueContext) IsDefaultValueContext() {} + +func NewDefaultValueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DefaultValueContext { + var p = new(DefaultValueContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_defaultValue + + return p +} + +func (s *DefaultValueContext) GetParser() antlr.Parser { return s.parser } + +func (s *DefaultValueContext) NULL_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserNULL_LITERAL, 0) +} + +func (s *DefaultValueContext) CAST() antlr.TerminalNode { + return s.GetToken(MySqlParserCAST, 0) +} + +func (s *DefaultValueContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *DefaultValueContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *DefaultValueContext) AS() antlr.TerminalNode { + return s.GetToken(MySqlParserAS, 0) +} + +func (s *DefaultValueContext) ConvertedDataType() IConvertedDataTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConvertedDataTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConvertedDataTypeContext) +} + +func (s *DefaultValueContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *DefaultValueContext) Constant() IConstantContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstantContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstantContext) +} + +func (s *DefaultValueContext) UnaryOperator() IUnaryOperatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnaryOperatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnaryOperatorContext) +} + +func (s *DefaultValueContext) AllCurrentTimestamp() []ICurrentTimestampContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICurrentTimestampContext); ok { + len++ + } + } + + tst := make([]ICurrentTimestampContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICurrentTimestampContext); ok { + tst[i] = t.(ICurrentTimestampContext) + i++ + } + } + + return tst +} + +func (s *DefaultValueContext) CurrentTimestamp(i int) ICurrentTimestampContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICurrentTimestampContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICurrentTimestampContext) +} + +func (s *DefaultValueContext) ON() antlr.TerminalNode { + return s.GetToken(MySqlParserON, 0) +} + +func (s *DefaultValueContext) UPDATE() antlr.TerminalNode { + return s.GetToken(MySqlParserUPDATE, 0) +} + +func (s *DefaultValueContext) FullId() IFullIdContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFullIdContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFullIdContext) +} + +func (s *DefaultValueContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DefaultValueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DefaultValueContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterDefaultValue(s) + } +} + +func (s *DefaultValueContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitDefaultValue(s) + } +} + +func (p *MySqlParser) DefaultValue() (localctx IDefaultValueContext) { + localctx = NewDefaultValueContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 634, MySqlParserRULE_defaultValue) + p.SetState(6776) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1010, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6750) + p.Match(MySqlParserNULL_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6751) + p.Match(MySqlParserCAST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6752) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6753) + p.expression(0) + } + { + p.SetState(6754) + p.Match(MySqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6755) + p.ConvertedDataType() + } + { + p.SetState(6756) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + p.SetState(6759) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1008, p.GetParserRuleContext()) == 1 { + { + p.SetState(6758) + p.UnaryOperator() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6761) + p.Constant() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(6762) + p.CurrentTimestamp() + } + p.SetState(6766) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1009, p.GetParserRuleContext()) == 1 { + { + p.SetState(6763) + p.Match(MySqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6764) + p.Match(MySqlParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6765) + p.CurrentTimestamp() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(6768) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6769) + p.expression(0) + } + { + p.SetState(6770) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(6772) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6773) + p.FullId() + } + { + p.SetState(6774) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICurrentTimestampContext is an interface to support dynamic dispatch. +type ICurrentTimestampContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NOW() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + CURRENT_TIMESTAMP() antlr.TerminalNode + LOCALTIME() antlr.TerminalNode + LOCALTIMESTAMP() antlr.TerminalNode + DecimalLiteral() IDecimalLiteralContext + + // IsCurrentTimestampContext differentiates from other interfaces. + IsCurrentTimestampContext() +} + +type CurrentTimestampContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCurrentTimestampContext() *CurrentTimestampContext { + var p = new(CurrentTimestampContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_currentTimestamp + return p +} + +func InitEmptyCurrentTimestampContext(p *CurrentTimestampContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_currentTimestamp +} + +func (*CurrentTimestampContext) IsCurrentTimestampContext() {} + +func NewCurrentTimestampContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CurrentTimestampContext { + var p = new(CurrentTimestampContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_currentTimestamp + + return p +} + +func (s *CurrentTimestampContext) GetParser() antlr.Parser { return s.parser } + +func (s *CurrentTimestampContext) NOW() antlr.TerminalNode { + return s.GetToken(MySqlParserNOW, 0) +} + +func (s *CurrentTimestampContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *CurrentTimestampContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *CurrentTimestampContext) CURRENT_TIMESTAMP() antlr.TerminalNode { + return s.GetToken(MySqlParserCURRENT_TIMESTAMP, 0) +} + +func (s *CurrentTimestampContext) LOCALTIME() antlr.TerminalNode { + return s.GetToken(MySqlParserLOCALTIME, 0) +} + +func (s *CurrentTimestampContext) LOCALTIMESTAMP() antlr.TerminalNode { + return s.GetToken(MySqlParserLOCALTIMESTAMP, 0) +} + +func (s *CurrentTimestampContext) DecimalLiteral() IDecimalLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *CurrentTimestampContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CurrentTimestampContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CurrentTimestampContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCurrentTimestamp(s) + } +} + +func (s *CurrentTimestampContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCurrentTimestamp(s) + } +} + +func (p *MySqlParser) CurrentTimestamp() (localctx ICurrentTimestampContext) { + localctx = NewCurrentTimestampContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 636, MySqlParserRULE_currentTimestamp) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(6792) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserCURRENT_TIMESTAMP, MySqlParserLOCALTIME, MySqlParserLOCALTIMESTAMP: + { + p.SetState(6778) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-316)) & ^0x3f) == 0 && ((int64(1)<<(_la-316))&131) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(6784) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1012, p.GetParserRuleContext()) == 1 { + { + p.SetState(6779) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6781) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if (int64((_la-1143)) & ^0x3f) == 0 && ((int64(1)<<(_la-1143))&10247) != 0 { + { + p.SetState(6780) + p.DecimalLiteral() + } + + } + { + p.SetState(6783) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case MySqlParserNOW: + { + p.SetState(6786) + p.Match(MySqlParserNOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6787) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6789) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if (int64((_la-1143)) & ^0x3f) == 0 && ((int64(1)<<(_la-1143))&10247) != 0 { + { + p.SetState(6788) + p.DecimalLiteral() + } + + } + { + p.SetState(6791) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExpressionOrDefaultContext is an interface to support dynamic dispatch. +type IExpressionOrDefaultContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + DEFAULT() antlr.TerminalNode + + // IsExpressionOrDefaultContext differentiates from other interfaces. + IsExpressionOrDefaultContext() +} + +type ExpressionOrDefaultContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExpressionOrDefaultContext() *ExpressionOrDefaultContext { + var p = new(ExpressionOrDefaultContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_expressionOrDefault + return p +} + +func InitEmptyExpressionOrDefaultContext(p *ExpressionOrDefaultContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_expressionOrDefault +} + +func (*ExpressionOrDefaultContext) IsExpressionOrDefaultContext() {} + +func NewExpressionOrDefaultContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionOrDefaultContext { + var p = new(ExpressionOrDefaultContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_expressionOrDefault + + return p +} + +func (s *ExpressionOrDefaultContext) GetParser() antlr.Parser { return s.parser } + +func (s *ExpressionOrDefaultContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *ExpressionOrDefaultContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(MySqlParserDEFAULT, 0) +} + +func (s *ExpressionOrDefaultContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ExpressionOrDefaultContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ExpressionOrDefaultContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterExpressionOrDefault(s) + } +} + +func (s *ExpressionOrDefaultContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitExpressionOrDefault(s) + } +} + +func (p *MySqlParser) ExpressionOrDefault() (localctx IExpressionOrDefaultContext) { + localctx = NewExpressionOrDefaultContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 638, MySqlParserRULE_expressionOrDefault) + p.SetState(6796) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1015, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6794) + p.expression(0) + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6795) + p.Match(MySqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIfExistsContext is an interface to support dynamic dispatch. +type IIfExistsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IF() antlr.TerminalNode + EXISTS() antlr.TerminalNode + + // IsIfExistsContext differentiates from other interfaces. + IsIfExistsContext() +} + +type IfExistsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIfExistsContext() *IfExistsContext { + var p = new(IfExistsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_ifExists + return p +} + +func InitEmptyIfExistsContext(p *IfExistsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_ifExists +} + +func (*IfExistsContext) IsIfExistsContext() {} + +func NewIfExistsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IfExistsContext { + var p = new(IfExistsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_ifExists + + return p +} + +func (s *IfExistsContext) GetParser() antlr.Parser { return s.parser } + +func (s *IfExistsContext) IF() antlr.TerminalNode { + return s.GetToken(MySqlParserIF, 0) +} + +func (s *IfExistsContext) EXISTS() antlr.TerminalNode { + return s.GetToken(MySqlParserEXISTS, 0) +} + +func (s *IfExistsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IfExistsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IfExistsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterIfExists(s) + } +} + +func (s *IfExistsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitIfExists(s) + } +} + +func (p *MySqlParser) IfExists() (localctx IIfExistsContext) { + localctx = NewIfExistsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 640, MySqlParserRULE_ifExists) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6798) + p.Match(MySqlParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6799) + p.Match(MySqlParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIfNotExistsContext is an interface to support dynamic dispatch. +type IIfNotExistsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IF() antlr.TerminalNode + NOT() antlr.TerminalNode + EXISTS() antlr.TerminalNode + + // IsIfNotExistsContext differentiates from other interfaces. + IsIfNotExistsContext() +} + +type IfNotExistsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIfNotExistsContext() *IfNotExistsContext { + var p = new(IfNotExistsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_ifNotExists + return p +} + +func InitEmptyIfNotExistsContext(p *IfNotExistsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_ifNotExists +} + +func (*IfNotExistsContext) IsIfNotExistsContext() {} + +func NewIfNotExistsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IfNotExistsContext { + var p = new(IfNotExistsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_ifNotExists + + return p +} + +func (s *IfNotExistsContext) GetParser() antlr.Parser { return s.parser } + +func (s *IfNotExistsContext) IF() antlr.TerminalNode { + return s.GetToken(MySqlParserIF, 0) +} + +func (s *IfNotExistsContext) NOT() antlr.TerminalNode { + return s.GetToken(MySqlParserNOT, 0) +} + +func (s *IfNotExistsContext) EXISTS() antlr.TerminalNode { + return s.GetToken(MySqlParserEXISTS, 0) +} + +func (s *IfNotExistsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IfNotExistsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IfNotExistsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterIfNotExists(s) + } +} + +func (s *IfNotExistsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitIfNotExists(s) + } +} + +func (p *MySqlParser) IfNotExists() (localctx IIfNotExistsContext) { + localctx = NewIfNotExistsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 642, MySqlParserRULE_ifNotExists) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6801) + p.Match(MySqlParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6802) + p.Match(MySqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6803) + p.Match(MySqlParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOrReplaceContext is an interface to support dynamic dispatch. +type IOrReplaceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OR() antlr.TerminalNode + REPLACE() antlr.TerminalNode + + // IsOrReplaceContext differentiates from other interfaces. + IsOrReplaceContext() +} + +type OrReplaceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOrReplaceContext() *OrReplaceContext { + var p = new(OrReplaceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_orReplace + return p +} + +func InitEmptyOrReplaceContext(p *OrReplaceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_orReplace +} + +func (*OrReplaceContext) IsOrReplaceContext() {} + +func NewOrReplaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OrReplaceContext { + var p = new(OrReplaceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_orReplace + + return p +} + +func (s *OrReplaceContext) GetParser() antlr.Parser { return s.parser } + +func (s *OrReplaceContext) OR() antlr.TerminalNode { + return s.GetToken(MySqlParserOR, 0) +} + +func (s *OrReplaceContext) REPLACE() antlr.TerminalNode { + return s.GetToken(MySqlParserREPLACE, 0) +} + +func (s *OrReplaceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *OrReplaceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *OrReplaceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterOrReplace(s) + } +} + +func (s *OrReplaceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitOrReplace(s) + } +} + +func (p *MySqlParser) OrReplace() (localctx IOrReplaceContext) { + localctx = NewOrReplaceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 644, MySqlParserRULE_orReplace) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6805) + p.Match(MySqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6806) + p.Match(MySqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWaitNowaitClauseContext is an interface to support dynamic dispatch. +type IWaitNowaitClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WAIT() antlr.TerminalNode + DecimalLiteral() IDecimalLiteralContext + NOWAIT() antlr.TerminalNode + + // IsWaitNowaitClauseContext differentiates from other interfaces. + IsWaitNowaitClauseContext() +} + +type WaitNowaitClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWaitNowaitClauseContext() *WaitNowaitClauseContext { + var p = new(WaitNowaitClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_waitNowaitClause + return p +} + +func InitEmptyWaitNowaitClauseContext(p *WaitNowaitClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_waitNowaitClause +} + +func (*WaitNowaitClauseContext) IsWaitNowaitClauseContext() {} + +func NewWaitNowaitClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WaitNowaitClauseContext { + var p = new(WaitNowaitClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_waitNowaitClause + + return p +} + +func (s *WaitNowaitClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *WaitNowaitClauseContext) WAIT() antlr.TerminalNode { + return s.GetToken(MySqlParserWAIT, 0) +} + +func (s *WaitNowaitClauseContext) DecimalLiteral() IDecimalLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *WaitNowaitClauseContext) NOWAIT() antlr.TerminalNode { + return s.GetToken(MySqlParserNOWAIT, 0) +} + +func (s *WaitNowaitClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *WaitNowaitClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *WaitNowaitClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterWaitNowaitClause(s) + } +} + +func (s *WaitNowaitClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitWaitNowaitClause(s) + } +} + +func (p *MySqlParser) WaitNowaitClause() (localctx IWaitNowaitClauseContext) { + localctx = NewWaitNowaitClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 646, MySqlParserRULE_waitNowaitClause) + p.SetState(6811) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserWAIT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6808) + p.Match(MySqlParserWAIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6809) + p.DecimalLiteral() + } + + case MySqlParserNOWAIT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6810) + p.Match(MySqlParserNOWAIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunctionCallContext is an interface to support dynamic dispatch. +type IFunctionCallContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsFunctionCallContext differentiates from other interfaces. + IsFunctionCallContext() +} + +type FunctionCallContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunctionCallContext() *FunctionCallContext { + var p = new(FunctionCallContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_functionCall + return p +} + +func InitEmptyFunctionCallContext(p *FunctionCallContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_functionCall +} + +func (*FunctionCallContext) IsFunctionCallContext() {} + +func NewFunctionCallContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionCallContext { + var p = new(FunctionCallContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_functionCall + + return p +} + +func (s *FunctionCallContext) GetParser() antlr.Parser { return s.parser } + +func (s *FunctionCallContext) CopyAll(ctx *FunctionCallContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *FunctionCallContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FunctionCallContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type SpecificFunctionCallContext struct { + FunctionCallContext +} + +func NewSpecificFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SpecificFunctionCallContext { + var p = new(SpecificFunctionCallContext) + + InitEmptyFunctionCallContext(&p.FunctionCallContext) + p.parser = parser + p.CopyAll(ctx.(*FunctionCallContext)) + + return p +} + +func (s *SpecificFunctionCallContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SpecificFunctionCallContext) SpecificFunction() ISpecificFunctionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISpecificFunctionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISpecificFunctionContext) +} + +func (s *SpecificFunctionCallContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSpecificFunctionCall(s) + } +} + +func (s *SpecificFunctionCallContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSpecificFunctionCall(s) + } +} + +type PasswordFunctionCallContext struct { + FunctionCallContext +} + +func NewPasswordFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PasswordFunctionCallContext { + var p = new(PasswordFunctionCallContext) + + InitEmptyFunctionCallContext(&p.FunctionCallContext) + p.parser = parser + p.CopyAll(ctx.(*FunctionCallContext)) + + return p +} + +func (s *PasswordFunctionCallContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PasswordFunctionCallContext) PasswordFunctionClause() IPasswordFunctionClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPasswordFunctionClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPasswordFunctionClauseContext) +} + +func (s *PasswordFunctionCallContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterPasswordFunctionCall(s) + } +} + +func (s *PasswordFunctionCallContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitPasswordFunctionCall(s) + } +} + +type UdfFunctionCallContext struct { + FunctionCallContext +} + +func NewUdfFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *UdfFunctionCallContext { + var p = new(UdfFunctionCallContext) + + InitEmptyFunctionCallContext(&p.FunctionCallContext) + p.parser = parser + p.CopyAll(ctx.(*FunctionCallContext)) + + return p +} + +func (s *UdfFunctionCallContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UdfFunctionCallContext) FullId() IFullIdContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFullIdContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFullIdContext) +} + +func (s *UdfFunctionCallContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *UdfFunctionCallContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *UdfFunctionCallContext) FunctionArgs() IFunctionArgsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionArgsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunctionArgsContext) +} + +func (s *UdfFunctionCallContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterUdfFunctionCall(s) + } +} + +func (s *UdfFunctionCallContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitUdfFunctionCall(s) + } +} + +type NonAggregateFunctionCallContext struct { + FunctionCallContext +} + +func NewNonAggregateFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NonAggregateFunctionCallContext { + var p = new(NonAggregateFunctionCallContext) + + InitEmptyFunctionCallContext(&p.FunctionCallContext) + p.parser = parser + p.CopyAll(ctx.(*FunctionCallContext)) + + return p +} + +func (s *NonAggregateFunctionCallContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *NonAggregateFunctionCallContext) NonAggregateWindowedFunction() INonAggregateWindowedFunctionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INonAggregateWindowedFunctionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INonAggregateWindowedFunctionContext) +} + +func (s *NonAggregateFunctionCallContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterNonAggregateFunctionCall(s) + } +} + +func (s *NonAggregateFunctionCallContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitNonAggregateFunctionCall(s) + } +} + +type AggregateFunctionCallContext struct { + FunctionCallContext +} + +func NewAggregateFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AggregateFunctionCallContext { + var p = new(AggregateFunctionCallContext) + + InitEmptyFunctionCallContext(&p.FunctionCallContext) + p.parser = parser + p.CopyAll(ctx.(*FunctionCallContext)) + + return p +} + +func (s *AggregateFunctionCallContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AggregateFunctionCallContext) AggregateWindowedFunction() IAggregateWindowedFunctionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAggregateWindowedFunctionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAggregateWindowedFunctionContext) +} + +func (s *AggregateFunctionCallContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAggregateFunctionCall(s) + } +} + +func (s *AggregateFunctionCallContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAggregateFunctionCall(s) + } +} + +type ScalarFunctionCallContext struct { + FunctionCallContext +} + +func NewScalarFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ScalarFunctionCallContext { + var p = new(ScalarFunctionCallContext) + + InitEmptyFunctionCallContext(&p.FunctionCallContext) + p.parser = parser + p.CopyAll(ctx.(*FunctionCallContext)) + + return p +} + +func (s *ScalarFunctionCallContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ScalarFunctionCallContext) ScalarFunctionName() IScalarFunctionNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IScalarFunctionNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IScalarFunctionNameContext) +} + +func (s *ScalarFunctionCallContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *ScalarFunctionCallContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *ScalarFunctionCallContext) FunctionArgs() IFunctionArgsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionArgsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunctionArgsContext) +} + +func (s *ScalarFunctionCallContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterScalarFunctionCall(s) + } +} + +func (s *ScalarFunctionCallContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitScalarFunctionCall(s) + } +} + +func (p *MySqlParser) FunctionCall() (localctx IFunctionCallContext) { + localctx = NewFunctionCallContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 648, MySqlParserRULE_functionCall) + p.SetState(6831) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1019, p.GetParserRuleContext()) { + case 1: + localctx = NewSpecificFunctionCallContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6813) + p.SpecificFunction() + } + + case 2: + localctx = NewAggregateFunctionCallContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6814) + p.AggregateWindowedFunction() + } + + case 3: + localctx = NewNonAggregateFunctionCallContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6815) + p.NonAggregateWindowedFunction() + } + + case 4: + localctx = NewScalarFunctionCallContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(6816) + p.ScalarFunctionName() + } + { + p.SetState(6817) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6819) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1017, p.GetParserRuleContext()) == 1 { + { + p.SetState(6818) + p.FunctionArgs() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6821) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + localctx = NewUdfFunctionCallContext(p, localctx) + p.EnterOuterAlt(localctx, 5) + { + p.SetState(6823) + p.FullId() + } + { + p.SetState(6824) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6826) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1018, p.GetParserRuleContext()) == 1 { + { + p.SetState(6825) + p.FunctionArgs() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6828) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + localctx = NewPasswordFunctionCallContext(p, localctx) + p.EnterOuterAlt(localctx, 6) + { + p.SetState(6830) + p.PasswordFunctionClause() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISpecificFunctionContext is an interface to support dynamic dispatch. +type ISpecificFunctionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsSpecificFunctionContext differentiates from other interfaces. + IsSpecificFunctionContext() +} + +type SpecificFunctionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySpecificFunctionContext() *SpecificFunctionContext { + var p = new(SpecificFunctionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_specificFunction + return p +} + +func InitEmptySpecificFunctionContext(p *SpecificFunctionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_specificFunction +} + +func (*SpecificFunctionContext) IsSpecificFunctionContext() {} + +func NewSpecificFunctionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SpecificFunctionContext { + var p = new(SpecificFunctionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_specificFunction + + return p +} + +func (s *SpecificFunctionContext) GetParser() antlr.Parser { return s.parser } + +func (s *SpecificFunctionContext) CopyAll(ctx *SpecificFunctionContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *SpecificFunctionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SpecificFunctionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type PositionFunctionCallContext struct { + SpecificFunctionContext + positionString IStringLiteralContext + positionExpression IExpressionContext + inString IStringLiteralContext + inExpression IExpressionContext +} + +func NewPositionFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PositionFunctionCallContext { + var p = new(PositionFunctionCallContext) + + InitEmptySpecificFunctionContext(&p.SpecificFunctionContext) + p.parser = parser + p.CopyAll(ctx.(*SpecificFunctionContext)) + + return p +} + +func (s *PositionFunctionCallContext) GetPositionString() IStringLiteralContext { + return s.positionString +} + +func (s *PositionFunctionCallContext) GetPositionExpression() IExpressionContext { + return s.positionExpression +} + +func (s *PositionFunctionCallContext) GetInString() IStringLiteralContext { return s.inString } + +func (s *PositionFunctionCallContext) GetInExpression() IExpressionContext { return s.inExpression } + +func (s *PositionFunctionCallContext) SetPositionString(v IStringLiteralContext) { + s.positionString = v +} + +func (s *PositionFunctionCallContext) SetPositionExpression(v IExpressionContext) { + s.positionExpression = v +} + +func (s *PositionFunctionCallContext) SetInString(v IStringLiteralContext) { s.inString = v } + +func (s *PositionFunctionCallContext) SetInExpression(v IExpressionContext) { s.inExpression = v } + +func (s *PositionFunctionCallContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PositionFunctionCallContext) POSITION() antlr.TerminalNode { + return s.GetToken(MySqlParserPOSITION, 0) +} + +func (s *PositionFunctionCallContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *PositionFunctionCallContext) IN() antlr.TerminalNode { + return s.GetToken(MySqlParserIN, 0) +} + +func (s *PositionFunctionCallContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *PositionFunctionCallContext) AllStringLiteral() []IStringLiteralContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStringLiteralContext); ok { + len++ + } + } + + tst := make([]IStringLiteralContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStringLiteralContext); ok { + tst[i] = t.(IStringLiteralContext) + i++ + } + } + + return tst +} + +func (s *PositionFunctionCallContext) StringLiteral(i int) IStringLiteralContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringLiteralContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStringLiteralContext) +} + +func (s *PositionFunctionCallContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *PositionFunctionCallContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *PositionFunctionCallContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterPositionFunctionCall(s) + } +} + +func (s *PositionFunctionCallContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitPositionFunctionCall(s) + } +} + +type TrimFunctionCallContext struct { + SpecificFunctionContext + positioinForm antlr.Token + sourceString IStringLiteralContext + sourceExpression IExpressionContext + fromString IStringLiteralContext + fromExpression IExpressionContext +} + +func NewTrimFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TrimFunctionCallContext { + var p = new(TrimFunctionCallContext) + + InitEmptySpecificFunctionContext(&p.SpecificFunctionContext) + p.parser = parser + p.CopyAll(ctx.(*SpecificFunctionContext)) + + return p +} + +func (s *TrimFunctionCallContext) GetPositioinForm() antlr.Token { return s.positioinForm } + +func (s *TrimFunctionCallContext) SetPositioinForm(v antlr.Token) { s.positioinForm = v } + +func (s *TrimFunctionCallContext) GetSourceString() IStringLiteralContext { return s.sourceString } + +func (s *TrimFunctionCallContext) GetSourceExpression() IExpressionContext { return s.sourceExpression } + +func (s *TrimFunctionCallContext) GetFromString() IStringLiteralContext { return s.fromString } + +func (s *TrimFunctionCallContext) GetFromExpression() IExpressionContext { return s.fromExpression } + +func (s *TrimFunctionCallContext) SetSourceString(v IStringLiteralContext) { s.sourceString = v } + +func (s *TrimFunctionCallContext) SetSourceExpression(v IExpressionContext) { s.sourceExpression = v } + +func (s *TrimFunctionCallContext) SetFromString(v IStringLiteralContext) { s.fromString = v } + +func (s *TrimFunctionCallContext) SetFromExpression(v IExpressionContext) { s.fromExpression = v } + +func (s *TrimFunctionCallContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TrimFunctionCallContext) TRIM() antlr.TerminalNode { + return s.GetToken(MySqlParserTRIM, 0) +} + +func (s *TrimFunctionCallContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *TrimFunctionCallContext) FROM() antlr.TerminalNode { + return s.GetToken(MySqlParserFROM, 0) +} + +func (s *TrimFunctionCallContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *TrimFunctionCallContext) BOTH() antlr.TerminalNode { + return s.GetToken(MySqlParserBOTH, 0) +} + +func (s *TrimFunctionCallContext) LEADING() antlr.TerminalNode { + return s.GetToken(MySqlParserLEADING, 0) +} + +func (s *TrimFunctionCallContext) TRAILING() antlr.TerminalNode { + return s.GetToken(MySqlParserTRAILING, 0) +} + +func (s *TrimFunctionCallContext) AllStringLiteral() []IStringLiteralContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStringLiteralContext); ok { + len++ + } + } + + tst := make([]IStringLiteralContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStringLiteralContext); ok { + tst[i] = t.(IStringLiteralContext) + i++ + } + } + + return tst +} + +func (s *TrimFunctionCallContext) StringLiteral(i int) IStringLiteralContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringLiteralContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStringLiteralContext) +} + +func (s *TrimFunctionCallContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *TrimFunctionCallContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *TrimFunctionCallContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTrimFunctionCall(s) + } +} + +func (s *TrimFunctionCallContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTrimFunctionCall(s) + } +} + +type JsonValueFunctionCallContext struct { + SpecificFunctionContext +} + +func NewJsonValueFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *JsonValueFunctionCallContext { + var p = new(JsonValueFunctionCallContext) + + InitEmptySpecificFunctionContext(&p.SpecificFunctionContext) + p.parser = parser + p.CopyAll(ctx.(*SpecificFunctionContext)) + + return p +} + +func (s *JsonValueFunctionCallContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *JsonValueFunctionCallContext) JSON_VALUE() antlr.TerminalNode { + return s.GetToken(MySqlParserJSON_VALUE, 0) +} + +func (s *JsonValueFunctionCallContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *JsonValueFunctionCallContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *JsonValueFunctionCallContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *JsonValueFunctionCallContext) COMMA() antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, 0) +} + +func (s *JsonValueFunctionCallContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *JsonValueFunctionCallContext) RETURNING() antlr.TerminalNode { + return s.GetToken(MySqlParserRETURNING, 0) +} + +func (s *JsonValueFunctionCallContext) ConvertedDataType() IConvertedDataTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConvertedDataTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConvertedDataTypeContext) +} + +func (s *JsonValueFunctionCallContext) JsonOnEmpty() IJsonOnEmptyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJsonOnEmptyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJsonOnEmptyContext) +} + +func (s *JsonValueFunctionCallContext) JsonOnError() IJsonOnErrorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJsonOnErrorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJsonOnErrorContext) +} + +func (s *JsonValueFunctionCallContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterJsonValueFunctionCall(s) + } +} + +func (s *JsonValueFunctionCallContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitJsonValueFunctionCall(s) + } +} + +type CaseFunctionCallContext struct { + SpecificFunctionContext + elseArg IFunctionArgContext +} + +func NewCaseFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CaseFunctionCallContext { + var p = new(CaseFunctionCallContext) + + InitEmptySpecificFunctionContext(&p.SpecificFunctionContext) + p.parser = parser + p.CopyAll(ctx.(*SpecificFunctionContext)) + + return p +} + +func (s *CaseFunctionCallContext) GetElseArg() IFunctionArgContext { return s.elseArg } + +func (s *CaseFunctionCallContext) SetElseArg(v IFunctionArgContext) { s.elseArg = v } + +func (s *CaseFunctionCallContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CaseFunctionCallContext) CASE() antlr.TerminalNode { + return s.GetToken(MySqlParserCASE, 0) +} + +func (s *CaseFunctionCallContext) END() antlr.TerminalNode { + return s.GetToken(MySqlParserEND, 0) +} + +func (s *CaseFunctionCallContext) AllCaseFuncAlternative() []ICaseFuncAlternativeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICaseFuncAlternativeContext); ok { + len++ + } + } + + tst := make([]ICaseFuncAlternativeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICaseFuncAlternativeContext); ok { + tst[i] = t.(ICaseFuncAlternativeContext) + i++ + } + } + + return tst +} + +func (s *CaseFunctionCallContext) CaseFuncAlternative(i int) ICaseFuncAlternativeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICaseFuncAlternativeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICaseFuncAlternativeContext) +} + +func (s *CaseFunctionCallContext) ELSE() antlr.TerminalNode { + return s.GetToken(MySqlParserELSE, 0) +} + +func (s *CaseFunctionCallContext) FunctionArg() IFunctionArgContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionArgContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunctionArgContext) +} + +func (s *CaseFunctionCallContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCaseFunctionCall(s) + } +} + +func (s *CaseFunctionCallContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCaseFunctionCall(s) + } +} + +type ExtractFunctionCallContext struct { + SpecificFunctionContext + sourceString IStringLiteralContext + sourceExpression IExpressionContext +} + +func NewExtractFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExtractFunctionCallContext { + var p = new(ExtractFunctionCallContext) + + InitEmptySpecificFunctionContext(&p.SpecificFunctionContext) + p.parser = parser + p.CopyAll(ctx.(*SpecificFunctionContext)) + + return p +} + +func (s *ExtractFunctionCallContext) GetSourceString() IStringLiteralContext { return s.sourceString } + +func (s *ExtractFunctionCallContext) GetSourceExpression() IExpressionContext { + return s.sourceExpression +} + +func (s *ExtractFunctionCallContext) SetSourceString(v IStringLiteralContext) { s.sourceString = v } + +func (s *ExtractFunctionCallContext) SetSourceExpression(v IExpressionContext) { + s.sourceExpression = v +} + +func (s *ExtractFunctionCallContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ExtractFunctionCallContext) EXTRACT() antlr.TerminalNode { + return s.GetToken(MySqlParserEXTRACT, 0) +} + +func (s *ExtractFunctionCallContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *ExtractFunctionCallContext) IntervalType() IIntervalTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIntervalTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIntervalTypeContext) +} + +func (s *ExtractFunctionCallContext) FROM() antlr.TerminalNode { + return s.GetToken(MySqlParserFROM, 0) +} + +func (s *ExtractFunctionCallContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *ExtractFunctionCallContext) StringLiteral() IStringLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringLiteralContext) +} + +func (s *ExtractFunctionCallContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *ExtractFunctionCallContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterExtractFunctionCall(s) + } +} + +func (s *ExtractFunctionCallContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitExtractFunctionCall(s) + } +} + +type DataTypeFunctionCallContext struct { + SpecificFunctionContext + separator antlr.Token +} + +func NewDataTypeFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DataTypeFunctionCallContext { + var p = new(DataTypeFunctionCallContext) + + InitEmptySpecificFunctionContext(&p.SpecificFunctionContext) + p.parser = parser + p.CopyAll(ctx.(*SpecificFunctionContext)) + + return p +} + +func (s *DataTypeFunctionCallContext) GetSeparator() antlr.Token { return s.separator } + +func (s *DataTypeFunctionCallContext) SetSeparator(v antlr.Token) { s.separator = v } + +func (s *DataTypeFunctionCallContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DataTypeFunctionCallContext) CONVERT() antlr.TerminalNode { + return s.GetToken(MySqlParserCONVERT, 0) +} + +func (s *DataTypeFunctionCallContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *DataTypeFunctionCallContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *DataTypeFunctionCallContext) ConvertedDataType() IConvertedDataTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConvertedDataTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConvertedDataTypeContext) +} + +func (s *DataTypeFunctionCallContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *DataTypeFunctionCallContext) COMMA() antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, 0) +} + +func (s *DataTypeFunctionCallContext) USING() antlr.TerminalNode { + return s.GetToken(MySqlParserUSING, 0) +} + +func (s *DataTypeFunctionCallContext) CharsetName() ICharsetNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICharsetNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICharsetNameContext) +} + +func (s *DataTypeFunctionCallContext) CAST() antlr.TerminalNode { + return s.GetToken(MySqlParserCAST, 0) +} + +func (s *DataTypeFunctionCallContext) AS() antlr.TerminalNode { + return s.GetToken(MySqlParserAS, 0) +} + +func (s *DataTypeFunctionCallContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterDataTypeFunctionCall(s) + } +} + +func (s *DataTypeFunctionCallContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitDataTypeFunctionCall(s) + } +} + +type ValuesFunctionCallContext struct { + SpecificFunctionContext +} + +func NewValuesFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ValuesFunctionCallContext { + var p = new(ValuesFunctionCallContext) + + InitEmptySpecificFunctionContext(&p.SpecificFunctionContext) + p.parser = parser + p.CopyAll(ctx.(*SpecificFunctionContext)) + + return p +} + +func (s *ValuesFunctionCallContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ValuesFunctionCallContext) VALUES() antlr.TerminalNode { + return s.GetToken(MySqlParserVALUES, 0) +} + +func (s *ValuesFunctionCallContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *ValuesFunctionCallContext) FullColumnName() IFullColumnNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFullColumnNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFullColumnNameContext) +} + +func (s *ValuesFunctionCallContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *ValuesFunctionCallContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterValuesFunctionCall(s) + } +} + +func (s *ValuesFunctionCallContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitValuesFunctionCall(s) + } +} + +type CaseExpressionFunctionCallContext struct { + SpecificFunctionContext + elseArg IFunctionArgContext +} + +func NewCaseExpressionFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CaseExpressionFunctionCallContext { + var p = new(CaseExpressionFunctionCallContext) + + InitEmptySpecificFunctionContext(&p.SpecificFunctionContext) + p.parser = parser + p.CopyAll(ctx.(*SpecificFunctionContext)) + + return p +} + +func (s *CaseExpressionFunctionCallContext) GetElseArg() IFunctionArgContext { return s.elseArg } + +func (s *CaseExpressionFunctionCallContext) SetElseArg(v IFunctionArgContext) { s.elseArg = v } + +func (s *CaseExpressionFunctionCallContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CaseExpressionFunctionCallContext) CASE() antlr.TerminalNode { + return s.GetToken(MySqlParserCASE, 0) +} + +func (s *CaseExpressionFunctionCallContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *CaseExpressionFunctionCallContext) END() antlr.TerminalNode { + return s.GetToken(MySqlParserEND, 0) +} + +func (s *CaseExpressionFunctionCallContext) AllCaseFuncAlternative() []ICaseFuncAlternativeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICaseFuncAlternativeContext); ok { + len++ + } + } + + tst := make([]ICaseFuncAlternativeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICaseFuncAlternativeContext); ok { + tst[i] = t.(ICaseFuncAlternativeContext) + i++ + } + } + + return tst +} + +func (s *CaseExpressionFunctionCallContext) CaseFuncAlternative(i int) ICaseFuncAlternativeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICaseFuncAlternativeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICaseFuncAlternativeContext) +} + +func (s *CaseExpressionFunctionCallContext) ELSE() antlr.TerminalNode { + return s.GetToken(MySqlParserELSE, 0) +} + +func (s *CaseExpressionFunctionCallContext) FunctionArg() IFunctionArgContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionArgContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunctionArgContext) +} + +func (s *CaseExpressionFunctionCallContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCaseExpressionFunctionCall(s) + } +} + +func (s *CaseExpressionFunctionCallContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCaseExpressionFunctionCall(s) + } +} + +type CurrentUserContext struct { + SpecificFunctionContext +} + +func NewCurrentUserContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CurrentUserContext { + var p = new(CurrentUserContext) + + InitEmptySpecificFunctionContext(&p.SpecificFunctionContext) + p.parser = parser + p.CopyAll(ctx.(*SpecificFunctionContext)) + + return p +} + +func (s *CurrentUserContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CurrentUserContext) CurrentUserExpression() ICurrentUserExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICurrentUserExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICurrentUserExpressionContext) +} + +func (s *CurrentUserContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCurrentUser(s) + } +} + +func (s *CurrentUserContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCurrentUser(s) + } +} + +type SimpleFunctionCallContext struct { + SpecificFunctionContext +} + +func NewSimpleFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SimpleFunctionCallContext { + var p = new(SimpleFunctionCallContext) + + InitEmptySpecificFunctionContext(&p.SpecificFunctionContext) + p.parser = parser + p.CopyAll(ctx.(*SpecificFunctionContext)) + + return p +} + +func (s *SimpleFunctionCallContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SimpleFunctionCallContext) CURRENT_DATE() antlr.TerminalNode { + return s.GetToken(MySqlParserCURRENT_DATE, 0) +} + +func (s *SimpleFunctionCallContext) CURRENT_TIME() antlr.TerminalNode { + return s.GetToken(MySqlParserCURRENT_TIME, 0) +} + +func (s *SimpleFunctionCallContext) CURRENT_TIMESTAMP() antlr.TerminalNode { + return s.GetToken(MySqlParserCURRENT_TIMESTAMP, 0) +} + +func (s *SimpleFunctionCallContext) LOCALTIME() antlr.TerminalNode { + return s.GetToken(MySqlParserLOCALTIME, 0) +} + +func (s *SimpleFunctionCallContext) UTC_TIMESTAMP() antlr.TerminalNode { + return s.GetToken(MySqlParserUTC_TIMESTAMP, 0) +} + +func (s *SimpleFunctionCallContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(MySqlParserSCHEMA, 0) +} + +func (s *SimpleFunctionCallContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *SimpleFunctionCallContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *SimpleFunctionCallContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSimpleFunctionCall(s) + } +} + +func (s *SimpleFunctionCallContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSimpleFunctionCall(s) + } +} + +type CharFunctionCallContext struct { + SpecificFunctionContext +} + +func NewCharFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CharFunctionCallContext { + var p = new(CharFunctionCallContext) + + InitEmptySpecificFunctionContext(&p.SpecificFunctionContext) + p.parser = parser + p.CopyAll(ctx.(*SpecificFunctionContext)) + + return p +} + +func (s *CharFunctionCallContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CharFunctionCallContext) CHAR() antlr.TerminalNode { + return s.GetToken(MySqlParserCHAR, 0) +} + +func (s *CharFunctionCallContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *CharFunctionCallContext) FunctionArgs() IFunctionArgsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionArgsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunctionArgsContext) +} + +func (s *CharFunctionCallContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *CharFunctionCallContext) USING() antlr.TerminalNode { + return s.GetToken(MySqlParserUSING, 0) +} + +func (s *CharFunctionCallContext) CharsetName() ICharsetNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICharsetNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICharsetNameContext) +} + +func (s *CharFunctionCallContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCharFunctionCall(s) + } +} + +func (s *CharFunctionCallContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCharFunctionCall(s) + } +} + +type WeightFunctionCallContext struct { + SpecificFunctionContext + stringFormat antlr.Token +} + +func NewWeightFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *WeightFunctionCallContext { + var p = new(WeightFunctionCallContext) + + InitEmptySpecificFunctionContext(&p.SpecificFunctionContext) + p.parser = parser + p.CopyAll(ctx.(*SpecificFunctionContext)) + + return p +} + +func (s *WeightFunctionCallContext) GetStringFormat() antlr.Token { return s.stringFormat } + +func (s *WeightFunctionCallContext) SetStringFormat(v antlr.Token) { s.stringFormat = v } + +func (s *WeightFunctionCallContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *WeightFunctionCallContext) WEIGHT_STRING() antlr.TerminalNode { + return s.GetToken(MySqlParserWEIGHT_STRING, 0) +} + +func (s *WeightFunctionCallContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(MySqlParserLR_BRACKET) +} + +func (s *WeightFunctionCallContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, i) +} + +func (s *WeightFunctionCallContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(MySqlParserRR_BRACKET) +} + +func (s *WeightFunctionCallContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, i) +} + +func (s *WeightFunctionCallContext) StringLiteral() IStringLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringLiteralContext) +} + +func (s *WeightFunctionCallContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *WeightFunctionCallContext) AS() antlr.TerminalNode { + return s.GetToken(MySqlParserAS, 0) +} + +func (s *WeightFunctionCallContext) DecimalLiteral() IDecimalLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *WeightFunctionCallContext) LevelsInWeightString() ILevelsInWeightStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILevelsInWeightStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILevelsInWeightStringContext) +} + +func (s *WeightFunctionCallContext) CHAR() antlr.TerminalNode { + return s.GetToken(MySqlParserCHAR, 0) +} + +func (s *WeightFunctionCallContext) BINARY() antlr.TerminalNode { + return s.GetToken(MySqlParserBINARY, 0) +} + +func (s *WeightFunctionCallContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterWeightFunctionCall(s) + } +} + +func (s *WeightFunctionCallContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitWeightFunctionCall(s) + } +} + +type GetFormatFunctionCallContext struct { + SpecificFunctionContext + datetimeFormat antlr.Token +} + +func NewGetFormatFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *GetFormatFunctionCallContext { + var p = new(GetFormatFunctionCallContext) + + InitEmptySpecificFunctionContext(&p.SpecificFunctionContext) + p.parser = parser + p.CopyAll(ctx.(*SpecificFunctionContext)) + + return p +} + +func (s *GetFormatFunctionCallContext) GetDatetimeFormat() antlr.Token { return s.datetimeFormat } + +func (s *GetFormatFunctionCallContext) SetDatetimeFormat(v antlr.Token) { s.datetimeFormat = v } + +func (s *GetFormatFunctionCallContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *GetFormatFunctionCallContext) GET_FORMAT() antlr.TerminalNode { + return s.GetToken(MySqlParserGET_FORMAT, 0) +} + +func (s *GetFormatFunctionCallContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *GetFormatFunctionCallContext) COMMA() antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, 0) +} + +func (s *GetFormatFunctionCallContext) StringLiteral() IStringLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringLiteralContext) +} + +func (s *GetFormatFunctionCallContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *GetFormatFunctionCallContext) DATE() antlr.TerminalNode { + return s.GetToken(MySqlParserDATE, 0) +} + +func (s *GetFormatFunctionCallContext) TIME() antlr.TerminalNode { + return s.GetToken(MySqlParserTIME, 0) +} + +func (s *GetFormatFunctionCallContext) DATETIME() antlr.TerminalNode { + return s.GetToken(MySqlParserDATETIME, 0) +} + +func (s *GetFormatFunctionCallContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterGetFormatFunctionCall(s) + } +} + +func (s *GetFormatFunctionCallContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitGetFormatFunctionCall(s) + } +} + +type SubstrFunctionCallContext struct { + SpecificFunctionContext + sourceString IStringLiteralContext + sourceExpression IExpressionContext + fromDecimal IDecimalLiteralContext + fromExpression IExpressionContext + forDecimal IDecimalLiteralContext + forExpression IExpressionContext +} + +func NewSubstrFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SubstrFunctionCallContext { + var p = new(SubstrFunctionCallContext) + + InitEmptySpecificFunctionContext(&p.SpecificFunctionContext) + p.parser = parser + p.CopyAll(ctx.(*SpecificFunctionContext)) + + return p +} + +func (s *SubstrFunctionCallContext) GetSourceString() IStringLiteralContext { return s.sourceString } + +func (s *SubstrFunctionCallContext) GetSourceExpression() IExpressionContext { + return s.sourceExpression +} + +func (s *SubstrFunctionCallContext) GetFromDecimal() IDecimalLiteralContext { return s.fromDecimal } + +func (s *SubstrFunctionCallContext) GetFromExpression() IExpressionContext { return s.fromExpression } + +func (s *SubstrFunctionCallContext) GetForDecimal() IDecimalLiteralContext { return s.forDecimal } + +func (s *SubstrFunctionCallContext) GetForExpression() IExpressionContext { return s.forExpression } + +func (s *SubstrFunctionCallContext) SetSourceString(v IStringLiteralContext) { s.sourceString = v } + +func (s *SubstrFunctionCallContext) SetSourceExpression(v IExpressionContext) { s.sourceExpression = v } + +func (s *SubstrFunctionCallContext) SetFromDecimal(v IDecimalLiteralContext) { s.fromDecimal = v } + +func (s *SubstrFunctionCallContext) SetFromExpression(v IExpressionContext) { s.fromExpression = v } + +func (s *SubstrFunctionCallContext) SetForDecimal(v IDecimalLiteralContext) { s.forDecimal = v } + +func (s *SubstrFunctionCallContext) SetForExpression(v IExpressionContext) { s.forExpression = v } + +func (s *SubstrFunctionCallContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SubstrFunctionCallContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *SubstrFunctionCallContext) FROM() antlr.TerminalNode { + return s.GetToken(MySqlParserFROM, 0) +} + +func (s *SubstrFunctionCallContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *SubstrFunctionCallContext) SUBSTR() antlr.TerminalNode { + return s.GetToken(MySqlParserSUBSTR, 0) +} + +func (s *SubstrFunctionCallContext) SUBSTRING() antlr.TerminalNode { + return s.GetToken(MySqlParserSUBSTRING, 0) +} + +func (s *SubstrFunctionCallContext) StringLiteral() IStringLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringLiteralContext) +} + +func (s *SubstrFunctionCallContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *SubstrFunctionCallContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *SubstrFunctionCallContext) AllDecimalLiteral() []IDecimalLiteralContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDecimalLiteralContext); ok { + len++ + } + } + + tst := make([]IDecimalLiteralContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDecimalLiteralContext); ok { + tst[i] = t.(IDecimalLiteralContext) + i++ + } + } + + return tst +} + +func (s *SubstrFunctionCallContext) DecimalLiteral(i int) IDecimalLiteralContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *SubstrFunctionCallContext) FOR() antlr.TerminalNode { + return s.GetToken(MySqlParserFOR, 0) +} + +func (s *SubstrFunctionCallContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSubstrFunctionCall(s) + } +} + +func (s *SubstrFunctionCallContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSubstrFunctionCall(s) + } +} + +func (p *MySqlParser) SpecificFunction() (localctx ISpecificFunctionContext) { + localctx = NewSpecificFunctionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 650, MySqlParserRULE_specificFunction) + var _la int + + p.SetState(7012) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1043, p.GetParserRuleContext()) { + case 1: + localctx = NewSimpleFunctionCallContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6833) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserSCHEMA || ((int64((_la-314)) & ^0x3f) == 0 && ((int64(1)<<(_la-314))&262159) != 0)) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(6836) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1020, p.GetParserRuleContext()) == 1 { + { + p.SetState(6834) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6835) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + localctx = NewCurrentUserContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6838) + p.CurrentUserExpression() + } + + case 3: + localctx = NewDataTypeFunctionCallContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6839) + p.Match(MySqlParserCONVERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6840) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6841) + p.expression(0) + } + { + p.SetState(6842) + + var _m = p.Match(MySqlParserCOMMA) + + localctx.(*DataTypeFunctionCallContext).separator = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6843) + p.ConvertedDataType() + } + { + p.SetState(6844) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + localctx = NewDataTypeFunctionCallContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(6846) + p.Match(MySqlParserCONVERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6847) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6848) + p.expression(0) + } + { + p.SetState(6849) + p.Match(MySqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6850) + p.CharsetName() + } + { + p.SetState(6851) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + localctx = NewDataTypeFunctionCallContext(p, localctx) + p.EnterOuterAlt(localctx, 5) + { + p.SetState(6853) + p.Match(MySqlParserCAST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6854) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6855) + p.expression(0) + } + { + p.SetState(6856) + p.Match(MySqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6857) + p.ConvertedDataType() + } + { + p.SetState(6858) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + localctx = NewValuesFunctionCallContext(p, localctx) + p.EnterOuterAlt(localctx, 6) + { + p.SetState(6860) + p.Match(MySqlParserVALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6861) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6862) + p.FullColumnName() + } + { + p.SetState(6863) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + localctx = NewCaseExpressionFunctionCallContext(p, localctx) + p.EnterOuterAlt(localctx, 7) + { + p.SetState(6865) + p.Match(MySqlParserCASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6866) + p.expression(0) + } + p.SetState(6868) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == MySqlParserWHEN { + { + p.SetState(6867) + p.CaseFuncAlternative() + } + + p.SetState(6870) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(6874) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserELSE { + { + p.SetState(6872) + p.Match(MySqlParserELSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6873) + + var _x = p.FunctionArg() + + localctx.(*CaseExpressionFunctionCallContext).elseArg = _x + } + + } + { + p.SetState(6876) + p.Match(MySqlParserEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + localctx = NewCaseFunctionCallContext(p, localctx) + p.EnterOuterAlt(localctx, 8) + { + p.SetState(6878) + p.Match(MySqlParserCASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6880) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == MySqlParserWHEN { + { + p.SetState(6879) + p.CaseFuncAlternative() + } + + p.SetState(6882) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(6886) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserELSE { + { + p.SetState(6884) + p.Match(MySqlParserELSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6885) + + var _x = p.FunctionArg() + + localctx.(*CaseFunctionCallContext).elseArg = _x + } + + } + { + p.SetState(6888) + p.Match(MySqlParserEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 9: + localctx = NewCharFunctionCallContext(p, localctx) + p.EnterOuterAlt(localctx, 9) + { + p.SetState(6890) + p.Match(MySqlParserCHAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6891) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6892) + p.FunctionArgs() + } + p.SetState(6895) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserUSING { + { + p.SetState(6893) + p.Match(MySqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6894) + p.CharsetName() + } + + } + { + p.SetState(6897) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 10: + localctx = NewPositionFunctionCallContext(p, localctx) + p.EnterOuterAlt(localctx, 10) + { + p.SetState(6899) + p.Match(MySqlParserPOSITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6900) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6903) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1026, p.GetParserRuleContext()) { + case 1: + { + p.SetState(6901) + + var _x = p.StringLiteral() + + localctx.(*PositionFunctionCallContext).positionString = _x + } + + case 2: + { + p.SetState(6902) + + var _x = p.expression(0) + + localctx.(*PositionFunctionCallContext).positionExpression = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(6905) + p.Match(MySqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6908) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1027, p.GetParserRuleContext()) { + case 1: + { + p.SetState(6906) + + var _x = p.StringLiteral() + + localctx.(*PositionFunctionCallContext).inString = _x + } + + case 2: + { + p.SetState(6907) + + var _x = p.expression(0) + + localctx.(*PositionFunctionCallContext).inExpression = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(6910) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 11: + localctx = NewSubstrFunctionCallContext(p, localctx) + p.EnterOuterAlt(localctx, 11) + { + p.SetState(6912) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserSUBSTR || _la == MySqlParserSUBSTRING) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(6913) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6916) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1028, p.GetParserRuleContext()) { + case 1: + { + p.SetState(6914) + + var _x = p.StringLiteral() + + localctx.(*SubstrFunctionCallContext).sourceString = _x + } + + case 2: + { + p.SetState(6915) + + var _x = p.expression(0) + + localctx.(*SubstrFunctionCallContext).sourceExpression = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(6918) + p.Match(MySqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6921) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1029, p.GetParserRuleContext()) { + case 1: + { + p.SetState(6919) + + var _x = p.DecimalLiteral() + + localctx.(*SubstrFunctionCallContext).fromDecimal = _x + } + + case 2: + { + p.SetState(6920) + + var _x = p.expression(0) + + localctx.(*SubstrFunctionCallContext).fromExpression = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(6928) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserFOR { + { + p.SetState(6923) + p.Match(MySqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6926) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1030, p.GetParserRuleContext()) { + case 1: + { + p.SetState(6924) + + var _x = p.DecimalLiteral() + + localctx.(*SubstrFunctionCallContext).forDecimal = _x + } + + case 2: + { + p.SetState(6925) + + var _x = p.expression(0) + + localctx.(*SubstrFunctionCallContext).forExpression = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + { + p.SetState(6930) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 12: + localctx = NewTrimFunctionCallContext(p, localctx) + p.EnterOuterAlt(localctx, 12) + { + p.SetState(6932) + p.Match(MySqlParserTRIM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6933) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6934) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*TrimFunctionCallContext).positioinForm = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserBOTH || _la == MySqlParserLEADING || _la == MySqlParserTRAILING) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*TrimFunctionCallContext).positioinForm = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(6937) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1032, p.GetParserRuleContext()) == 1 { + { + p.SetState(6935) + + var _x = p.StringLiteral() + + localctx.(*TrimFunctionCallContext).sourceString = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1032, p.GetParserRuleContext()) == 2 { + { + p.SetState(6936) + + var _x = p.expression(0) + + localctx.(*TrimFunctionCallContext).sourceExpression = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6939) + p.Match(MySqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6942) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1033, p.GetParserRuleContext()) { + case 1: + { + p.SetState(6940) + + var _x = p.StringLiteral() + + localctx.(*TrimFunctionCallContext).fromString = _x + } + + case 2: + { + p.SetState(6941) + + var _x = p.expression(0) + + localctx.(*TrimFunctionCallContext).fromExpression = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(6944) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 13: + localctx = NewTrimFunctionCallContext(p, localctx) + p.EnterOuterAlt(localctx, 13) + { + p.SetState(6946) + p.Match(MySqlParserTRIM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6947) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6950) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1034, p.GetParserRuleContext()) { + case 1: + { + p.SetState(6948) + + var _x = p.StringLiteral() + + localctx.(*TrimFunctionCallContext).sourceString = _x + } + + case 2: + { + p.SetState(6949) + + var _x = p.expression(0) + + localctx.(*TrimFunctionCallContext).sourceExpression = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(6952) + p.Match(MySqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6955) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1035, p.GetParserRuleContext()) { + case 1: + { + p.SetState(6953) + + var _x = p.StringLiteral() + + localctx.(*TrimFunctionCallContext).fromString = _x + } + + case 2: + { + p.SetState(6954) + + var _x = p.expression(0) + + localctx.(*TrimFunctionCallContext).fromExpression = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(6957) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 14: + localctx = NewWeightFunctionCallContext(p, localctx) + p.EnterOuterAlt(localctx, 14) + { + p.SetState(6959) + p.Match(MySqlParserWEIGHT_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6960) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6963) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1036, p.GetParserRuleContext()) { + case 1: + { + p.SetState(6961) + p.StringLiteral() + } + + case 2: + { + p.SetState(6962) + p.expression(0) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(6971) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserAS { + { + p.SetState(6965) + p.Match(MySqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6966) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*WeightFunctionCallContext).stringFormat = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserCHAR || _la == MySqlParserBINARY) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*WeightFunctionCallContext).stringFormat = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(6967) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6968) + p.DecimalLiteral() + } + { + p.SetState(6969) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(6974) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserLEVEL { + { + p.SetState(6973) + p.LevelsInWeightString() + } + + } + { + p.SetState(6976) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 15: + localctx = NewExtractFunctionCallContext(p, localctx) + p.EnterOuterAlt(localctx, 15) + { + p.SetState(6978) + p.Match(MySqlParserEXTRACT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6979) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6980) + p.IntervalType() + } + { + p.SetState(6981) + p.Match(MySqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6984) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1039, p.GetParserRuleContext()) { + case 1: + { + p.SetState(6982) + + var _x = p.StringLiteral() + + localctx.(*ExtractFunctionCallContext).sourceString = _x + } + + case 2: + { + p.SetState(6983) + + var _x = p.expression(0) + + localctx.(*ExtractFunctionCallContext).sourceExpression = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(6986) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 16: + localctx = NewGetFormatFunctionCallContext(p, localctx) + p.EnterOuterAlt(localctx, 16) + { + p.SetState(6988) + p.Match(MySqlParserGET_FORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6989) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6990) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*GetFormatFunctionCallContext).datetimeFormat = _lt + + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&11) != 0) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*GetFormatFunctionCallContext).datetimeFormat = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(6991) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6992) + p.StringLiteral() + } + { + p.SetState(6993) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 17: + localctx = NewJsonValueFunctionCallContext(p, localctx) + p.EnterOuterAlt(localctx, 17) + { + p.SetState(6995) + p.Match(MySqlParserJSON_VALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6996) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6997) + p.expression(0) + } + { + p.SetState(6998) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6999) + p.expression(0) + } + p.SetState(7002) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserRETURNING { + { + p.SetState(7000) + p.Match(MySqlParserRETURNING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7001) + p.ConvertedDataType() + } + + } + p.SetState(7005) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1041, p.GetParserRuleContext()) == 1 { + { + p.SetState(7004) + p.JsonOnEmpty() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(7008) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserDEFAULT || _la == MySqlParserNULL_LITERAL || _la == MySqlParserERROR { + { + p.SetState(7007) + p.JsonOnError() + } + + } + { + p.SetState(7010) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICaseFuncAlternativeContext is an interface to support dynamic dispatch. +type ICaseFuncAlternativeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetCondition returns the condition rule contexts. + GetCondition() IFunctionArgContext + + // GetConsequent returns the consequent rule contexts. + GetConsequent() IFunctionArgContext + + // SetCondition sets the condition rule contexts. + SetCondition(IFunctionArgContext) + + // SetConsequent sets the consequent rule contexts. + SetConsequent(IFunctionArgContext) + + // Getter signatures + WHEN() antlr.TerminalNode + THEN() antlr.TerminalNode + AllFunctionArg() []IFunctionArgContext + FunctionArg(i int) IFunctionArgContext + + // IsCaseFuncAlternativeContext differentiates from other interfaces. + IsCaseFuncAlternativeContext() +} + +type CaseFuncAlternativeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + condition IFunctionArgContext + consequent IFunctionArgContext +} + +func NewEmptyCaseFuncAlternativeContext() *CaseFuncAlternativeContext { + var p = new(CaseFuncAlternativeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_caseFuncAlternative + return p +} + +func InitEmptyCaseFuncAlternativeContext(p *CaseFuncAlternativeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_caseFuncAlternative +} + +func (*CaseFuncAlternativeContext) IsCaseFuncAlternativeContext() {} + +func NewCaseFuncAlternativeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CaseFuncAlternativeContext { + var p = new(CaseFuncAlternativeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_caseFuncAlternative + + return p +} + +func (s *CaseFuncAlternativeContext) GetParser() antlr.Parser { return s.parser } + +func (s *CaseFuncAlternativeContext) GetCondition() IFunctionArgContext { return s.condition } + +func (s *CaseFuncAlternativeContext) GetConsequent() IFunctionArgContext { return s.consequent } + +func (s *CaseFuncAlternativeContext) SetCondition(v IFunctionArgContext) { s.condition = v } + +func (s *CaseFuncAlternativeContext) SetConsequent(v IFunctionArgContext) { s.consequent = v } + +func (s *CaseFuncAlternativeContext) WHEN() antlr.TerminalNode { + return s.GetToken(MySqlParserWHEN, 0) +} + +func (s *CaseFuncAlternativeContext) THEN() antlr.TerminalNode { + return s.GetToken(MySqlParserTHEN, 0) +} + +func (s *CaseFuncAlternativeContext) AllFunctionArg() []IFunctionArgContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFunctionArgContext); ok { + len++ + } + } + + tst := make([]IFunctionArgContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFunctionArgContext); ok { + tst[i] = t.(IFunctionArgContext) + i++ + } + } + + return tst +} + +func (s *CaseFuncAlternativeContext) FunctionArg(i int) IFunctionArgContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionArgContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFunctionArgContext) +} + +func (s *CaseFuncAlternativeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CaseFuncAlternativeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CaseFuncAlternativeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCaseFuncAlternative(s) + } +} + +func (s *CaseFuncAlternativeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCaseFuncAlternative(s) + } +} + +func (p *MySqlParser) CaseFuncAlternative() (localctx ICaseFuncAlternativeContext) { + localctx = NewCaseFuncAlternativeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 652, MySqlParserRULE_caseFuncAlternative) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7014) + p.Match(MySqlParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7015) + + var _x = p.FunctionArg() + + localctx.(*CaseFuncAlternativeContext).condition = _x + } + { + p.SetState(7016) + p.Match(MySqlParserTHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7017) + + var _x = p.FunctionArg() + + localctx.(*CaseFuncAlternativeContext).consequent = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILevelsInWeightStringContext is an interface to support dynamic dispatch. +type ILevelsInWeightStringContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsLevelsInWeightStringContext differentiates from other interfaces. + IsLevelsInWeightStringContext() +} + +type LevelsInWeightStringContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLevelsInWeightStringContext() *LevelsInWeightStringContext { + var p = new(LevelsInWeightStringContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_levelsInWeightString + return p +} + +func InitEmptyLevelsInWeightStringContext(p *LevelsInWeightStringContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_levelsInWeightString +} + +func (*LevelsInWeightStringContext) IsLevelsInWeightStringContext() {} + +func NewLevelsInWeightStringContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LevelsInWeightStringContext { + var p = new(LevelsInWeightStringContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_levelsInWeightString + + return p +} + +func (s *LevelsInWeightStringContext) GetParser() antlr.Parser { return s.parser } + +func (s *LevelsInWeightStringContext) CopyAll(ctx *LevelsInWeightStringContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *LevelsInWeightStringContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LevelsInWeightStringContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type LevelWeightRangeContext struct { + LevelsInWeightStringContext + firstLevel IDecimalLiteralContext + lastLevel IDecimalLiteralContext +} + +func NewLevelWeightRangeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LevelWeightRangeContext { + var p = new(LevelWeightRangeContext) + + InitEmptyLevelsInWeightStringContext(&p.LevelsInWeightStringContext) + p.parser = parser + p.CopyAll(ctx.(*LevelsInWeightStringContext)) + + return p +} + +func (s *LevelWeightRangeContext) GetFirstLevel() IDecimalLiteralContext { return s.firstLevel } + +func (s *LevelWeightRangeContext) GetLastLevel() IDecimalLiteralContext { return s.lastLevel } + +func (s *LevelWeightRangeContext) SetFirstLevel(v IDecimalLiteralContext) { s.firstLevel = v } + +func (s *LevelWeightRangeContext) SetLastLevel(v IDecimalLiteralContext) { s.lastLevel = v } + +func (s *LevelWeightRangeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LevelWeightRangeContext) LEVEL() antlr.TerminalNode { + return s.GetToken(MySqlParserLEVEL, 0) +} + +func (s *LevelWeightRangeContext) MINUS() antlr.TerminalNode { + return s.GetToken(MySqlParserMINUS, 0) +} + +func (s *LevelWeightRangeContext) AllDecimalLiteral() []IDecimalLiteralContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDecimalLiteralContext); ok { + len++ + } + } + + tst := make([]IDecimalLiteralContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDecimalLiteralContext); ok { + tst[i] = t.(IDecimalLiteralContext) + i++ + } + } + + return tst +} + +func (s *LevelWeightRangeContext) DecimalLiteral(i int) IDecimalLiteralContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *LevelWeightRangeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterLevelWeightRange(s) + } +} + +func (s *LevelWeightRangeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitLevelWeightRange(s) + } +} + +type LevelWeightListContext struct { + LevelsInWeightStringContext +} + +func NewLevelWeightListContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LevelWeightListContext { + var p = new(LevelWeightListContext) + + InitEmptyLevelsInWeightStringContext(&p.LevelsInWeightStringContext) + p.parser = parser + p.CopyAll(ctx.(*LevelsInWeightStringContext)) + + return p +} + +func (s *LevelWeightListContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LevelWeightListContext) LEVEL() antlr.TerminalNode { + return s.GetToken(MySqlParserLEVEL, 0) +} + +func (s *LevelWeightListContext) AllLevelInWeightListElement() []ILevelInWeightListElementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILevelInWeightListElementContext); ok { + len++ + } + } + + tst := make([]ILevelInWeightListElementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILevelInWeightListElementContext); ok { + tst[i] = t.(ILevelInWeightListElementContext) + i++ + } + } + + return tst +} + +func (s *LevelWeightListContext) LevelInWeightListElement(i int) ILevelInWeightListElementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILevelInWeightListElementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILevelInWeightListElementContext) +} + +func (s *LevelWeightListContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *LevelWeightListContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *LevelWeightListContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterLevelWeightList(s) + } +} + +func (s *LevelWeightListContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitLevelWeightList(s) + } +} + +func (p *MySqlParser) LevelsInWeightString() (localctx ILevelsInWeightStringContext) { + localctx = NewLevelsInWeightStringContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 654, MySqlParserRULE_levelsInWeightString) + var _la int + + p.SetState(7033) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1045, p.GetParserRuleContext()) { + case 1: + localctx = NewLevelWeightListContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7019) + p.Match(MySqlParserLEVEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7020) + p.LevelInWeightListElement() + } + p.SetState(7025) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(7021) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7022) + p.LevelInWeightListElement() + } + + p.SetState(7027) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 2: + localctx = NewLevelWeightRangeContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7028) + p.Match(MySqlParserLEVEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7029) + + var _x = p.DecimalLiteral() + + localctx.(*LevelWeightRangeContext).firstLevel = _x + } + { + p.SetState(7030) + p.Match(MySqlParserMINUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7031) + + var _x = p.DecimalLiteral() + + localctx.(*LevelWeightRangeContext).lastLevel = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILevelInWeightListElementContext is an interface to support dynamic dispatch. +type ILevelInWeightListElementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetOrderType returns the orderType token. + GetOrderType() antlr.Token + + // SetOrderType sets the orderType token. + SetOrderType(antlr.Token) + + // Getter signatures + DecimalLiteral() IDecimalLiteralContext + ASC() antlr.TerminalNode + DESC() antlr.TerminalNode + REVERSE() antlr.TerminalNode + + // IsLevelInWeightListElementContext differentiates from other interfaces. + IsLevelInWeightListElementContext() +} + +type LevelInWeightListElementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + orderType antlr.Token +} + +func NewEmptyLevelInWeightListElementContext() *LevelInWeightListElementContext { + var p = new(LevelInWeightListElementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_levelInWeightListElement + return p +} + +func InitEmptyLevelInWeightListElementContext(p *LevelInWeightListElementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_levelInWeightListElement +} + +func (*LevelInWeightListElementContext) IsLevelInWeightListElementContext() {} + +func NewLevelInWeightListElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LevelInWeightListElementContext { + var p = new(LevelInWeightListElementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_levelInWeightListElement + + return p +} + +func (s *LevelInWeightListElementContext) GetParser() antlr.Parser { return s.parser } + +func (s *LevelInWeightListElementContext) GetOrderType() antlr.Token { return s.orderType } + +func (s *LevelInWeightListElementContext) SetOrderType(v antlr.Token) { s.orderType = v } + +func (s *LevelInWeightListElementContext) DecimalLiteral() IDecimalLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *LevelInWeightListElementContext) ASC() antlr.TerminalNode { + return s.GetToken(MySqlParserASC, 0) +} + +func (s *LevelInWeightListElementContext) DESC() antlr.TerminalNode { + return s.GetToken(MySqlParserDESC, 0) +} + +func (s *LevelInWeightListElementContext) REVERSE() antlr.TerminalNode { + return s.GetToken(MySqlParserREVERSE, 0) +} + +func (s *LevelInWeightListElementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LevelInWeightListElementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *LevelInWeightListElementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterLevelInWeightListElement(s) + } +} + +func (s *LevelInWeightListElementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitLevelInWeightListElement(s) + } +} + +func (p *MySqlParser) LevelInWeightListElement() (localctx ILevelInWeightListElementContext) { + localctx = NewLevelInWeightListElementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 656, MySqlParserRULE_levelInWeightListElement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7035) + p.DecimalLiteral() + } + p.SetState(7037) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserASC || _la == MySqlParserDESC || _la == MySqlParserREVERSE { + { + p.SetState(7036) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*LevelInWeightListElementContext).orderType = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserASC || _la == MySqlParserDESC || _la == MySqlParserREVERSE) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*LevelInWeightListElementContext).orderType = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAggregateWindowedFunctionContext is an interface to support dynamic dispatch. +type IAggregateWindowedFunctionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetAggregator returns the aggregator token. + GetAggregator() antlr.Token + + // GetStarArg returns the starArg token. + GetStarArg() antlr.Token + + // GetSeparator returns the separator token. + GetSeparator() antlr.Token + + // SetAggregator sets the aggregator token. + SetAggregator(antlr.Token) + + // SetStarArg sets the starArg token. + SetStarArg(antlr.Token) + + // SetSeparator sets the separator token. + SetSeparator(antlr.Token) + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + FunctionArg() IFunctionArgContext + RR_BRACKET() antlr.TerminalNode + AVG() antlr.TerminalNode + MAX() antlr.TerminalNode + MIN() antlr.TerminalNode + SUM() antlr.TerminalNode + OverClause() IOverClauseContext + ALL() antlr.TerminalNode + DISTINCT() antlr.TerminalNode + COUNT() antlr.TerminalNode + FunctionArgs() IFunctionArgsContext + STAR() antlr.TerminalNode + BIT_AND() antlr.TerminalNode + BIT_OR() antlr.TerminalNode + BIT_XOR() antlr.TerminalNode + STD() antlr.TerminalNode + STDDEV() antlr.TerminalNode + STDDEV_POP() antlr.TerminalNode + STDDEV_SAMP() antlr.TerminalNode + VAR_POP() antlr.TerminalNode + VAR_SAMP() antlr.TerminalNode + VARIANCE() antlr.TerminalNode + GROUP_CONCAT() antlr.TerminalNode + ORDER() antlr.TerminalNode + BY() antlr.TerminalNode + AllOrderByExpression() []IOrderByExpressionContext + OrderByExpression(i int) IOrderByExpressionContext + SEPARATOR() antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAggregateWindowedFunctionContext differentiates from other interfaces. + IsAggregateWindowedFunctionContext() +} + +type AggregateWindowedFunctionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + aggregator antlr.Token + starArg antlr.Token + separator antlr.Token +} + +func NewEmptyAggregateWindowedFunctionContext() *AggregateWindowedFunctionContext { + var p = new(AggregateWindowedFunctionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_aggregateWindowedFunction + return p +} + +func InitEmptyAggregateWindowedFunctionContext(p *AggregateWindowedFunctionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_aggregateWindowedFunction +} + +func (*AggregateWindowedFunctionContext) IsAggregateWindowedFunctionContext() {} + +func NewAggregateWindowedFunctionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AggregateWindowedFunctionContext { + var p = new(AggregateWindowedFunctionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_aggregateWindowedFunction + + return p +} + +func (s *AggregateWindowedFunctionContext) GetParser() antlr.Parser { return s.parser } + +func (s *AggregateWindowedFunctionContext) GetAggregator() antlr.Token { return s.aggregator } + +func (s *AggregateWindowedFunctionContext) GetStarArg() antlr.Token { return s.starArg } + +func (s *AggregateWindowedFunctionContext) GetSeparator() antlr.Token { return s.separator } + +func (s *AggregateWindowedFunctionContext) SetAggregator(v antlr.Token) { s.aggregator = v } + +func (s *AggregateWindowedFunctionContext) SetStarArg(v antlr.Token) { s.starArg = v } + +func (s *AggregateWindowedFunctionContext) SetSeparator(v antlr.Token) { s.separator = v } + +func (s *AggregateWindowedFunctionContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *AggregateWindowedFunctionContext) FunctionArg() IFunctionArgContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionArgContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunctionArgContext) +} + +func (s *AggregateWindowedFunctionContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *AggregateWindowedFunctionContext) AVG() antlr.TerminalNode { + return s.GetToken(MySqlParserAVG, 0) +} + +func (s *AggregateWindowedFunctionContext) MAX() antlr.TerminalNode { + return s.GetToken(MySqlParserMAX, 0) +} + +func (s *AggregateWindowedFunctionContext) MIN() antlr.TerminalNode { + return s.GetToken(MySqlParserMIN, 0) +} + +func (s *AggregateWindowedFunctionContext) SUM() antlr.TerminalNode { + return s.GetToken(MySqlParserSUM, 0) +} + +func (s *AggregateWindowedFunctionContext) OverClause() IOverClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOverClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOverClauseContext) +} + +func (s *AggregateWindowedFunctionContext) ALL() antlr.TerminalNode { + return s.GetToken(MySqlParserALL, 0) +} + +func (s *AggregateWindowedFunctionContext) DISTINCT() antlr.TerminalNode { + return s.GetToken(MySqlParserDISTINCT, 0) +} + +func (s *AggregateWindowedFunctionContext) COUNT() antlr.TerminalNode { + return s.GetToken(MySqlParserCOUNT, 0) +} + +func (s *AggregateWindowedFunctionContext) FunctionArgs() IFunctionArgsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionArgsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunctionArgsContext) +} + +func (s *AggregateWindowedFunctionContext) STAR() antlr.TerminalNode { + return s.GetToken(MySqlParserSTAR, 0) +} + +func (s *AggregateWindowedFunctionContext) BIT_AND() antlr.TerminalNode { + return s.GetToken(MySqlParserBIT_AND, 0) +} + +func (s *AggregateWindowedFunctionContext) BIT_OR() antlr.TerminalNode { + return s.GetToken(MySqlParserBIT_OR, 0) +} + +func (s *AggregateWindowedFunctionContext) BIT_XOR() antlr.TerminalNode { + return s.GetToken(MySqlParserBIT_XOR, 0) +} + +func (s *AggregateWindowedFunctionContext) STD() antlr.TerminalNode { + return s.GetToken(MySqlParserSTD, 0) +} + +func (s *AggregateWindowedFunctionContext) STDDEV() antlr.TerminalNode { + return s.GetToken(MySqlParserSTDDEV, 0) +} + +func (s *AggregateWindowedFunctionContext) STDDEV_POP() antlr.TerminalNode { + return s.GetToken(MySqlParserSTDDEV_POP, 0) +} + +func (s *AggregateWindowedFunctionContext) STDDEV_SAMP() antlr.TerminalNode { + return s.GetToken(MySqlParserSTDDEV_SAMP, 0) +} + +func (s *AggregateWindowedFunctionContext) VAR_POP() antlr.TerminalNode { + return s.GetToken(MySqlParserVAR_POP, 0) +} + +func (s *AggregateWindowedFunctionContext) VAR_SAMP() antlr.TerminalNode { + return s.GetToken(MySqlParserVAR_SAMP, 0) +} + +func (s *AggregateWindowedFunctionContext) VARIANCE() antlr.TerminalNode { + return s.GetToken(MySqlParserVARIANCE, 0) +} + +func (s *AggregateWindowedFunctionContext) GROUP_CONCAT() antlr.TerminalNode { + return s.GetToken(MySqlParserGROUP_CONCAT, 0) +} + +func (s *AggregateWindowedFunctionContext) ORDER() antlr.TerminalNode { + return s.GetToken(MySqlParserORDER, 0) +} + +func (s *AggregateWindowedFunctionContext) BY() antlr.TerminalNode { + return s.GetToken(MySqlParserBY, 0) +} + +func (s *AggregateWindowedFunctionContext) AllOrderByExpression() []IOrderByExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOrderByExpressionContext); ok { + len++ + } + } + + tst := make([]IOrderByExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOrderByExpressionContext); ok { + tst[i] = t.(IOrderByExpressionContext) + i++ + } + } + + return tst +} + +func (s *AggregateWindowedFunctionContext) OrderByExpression(i int) IOrderByExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOrderByExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOrderByExpressionContext) +} + +func (s *AggregateWindowedFunctionContext) SEPARATOR() antlr.TerminalNode { + return s.GetToken(MySqlParserSEPARATOR, 0) +} + +func (s *AggregateWindowedFunctionContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *AggregateWindowedFunctionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *AggregateWindowedFunctionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *AggregateWindowedFunctionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AggregateWindowedFunctionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AggregateWindowedFunctionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAggregateWindowedFunction(s) + } +} + +func (s *AggregateWindowedFunctionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAggregateWindowedFunction(s) + } +} + +func (p *MySqlParser) AggregateWindowedFunction() (localctx IAggregateWindowedFunctionContext) { + localctx = NewAggregateWindowedFunctionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 658, MySqlParserRULE_aggregateWindowedFunction) + var _la int + + p.SetState(7098) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserAVG, MySqlParserMAX, MySqlParserMIN, MySqlParserSUM: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7039) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-287)) & ^0x3f) == 0 && ((int64(1)<<(_la-287))&8400897) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(7040) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7042) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1047, p.GetParserRuleContext()) == 1 { + { + p.SetState(7041) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*AggregateWindowedFunctionContext).aggregator = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserALL || _la == MySqlParserDISTINCT) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*AggregateWindowedFunctionContext).aggregator = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(7044) + p.FunctionArg() + } + { + p.SetState(7045) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7047) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1048, p.GetParserRuleContext()) == 1 { + { + p.SetState(7046) + p.OverClause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case MySqlParserCOUNT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7049) + p.Match(MySqlParserCOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7050) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7058) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1050, p.GetParserRuleContext()) { + case 1: + { + p.SetState(7051) + + var _m = p.Match(MySqlParserSTAR) + + localctx.(*AggregateWindowedFunctionContext).starArg = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.SetState(7053) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1049, p.GetParserRuleContext()) == 1 { + { + p.SetState(7052) + + var _m = p.Match(MySqlParserALL) + + localctx.(*AggregateWindowedFunctionContext).aggregator = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(7055) + p.FunctionArg() + } + + case 3: + { + p.SetState(7056) + + var _m = p.Match(MySqlParserDISTINCT) + + localctx.(*AggregateWindowedFunctionContext).aggregator = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7057) + p.FunctionArgs() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(7060) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7062) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1051, p.GetParserRuleContext()) == 1 { + { + p.SetState(7061) + p.OverClause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case MySqlParserBIT_AND, MySqlParserBIT_OR, MySqlParserBIT_XOR, MySqlParserSTD, MySqlParserSTDDEV, MySqlParserSTDDEV_POP, MySqlParserSTDDEV_SAMP, MySqlParserVAR_POP, MySqlParserVAR_SAMP, MySqlParserVARIANCE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(7064) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-288)) & ^0x3f) == 0 && ((int64(1)<<(_la-288))&62652423) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(7065) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7067) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1052, p.GetParserRuleContext()) == 1 { + { + p.SetState(7066) + + var _m = p.Match(MySqlParserALL) + + localctx.(*AggregateWindowedFunctionContext).aggregator = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(7069) + p.FunctionArg() + } + { + p.SetState(7070) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7072) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1053, p.GetParserRuleContext()) == 1 { + { + p.SetState(7071) + p.OverClause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case MySqlParserGROUP_CONCAT: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(7074) + p.Match(MySqlParserGROUP_CONCAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7075) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7077) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1054, p.GetParserRuleContext()) == 1 { + { + p.SetState(7076) + + var _m = p.Match(MySqlParserDISTINCT) + + localctx.(*AggregateWindowedFunctionContext).aggregator = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(7079) + p.FunctionArgs() + } + p.SetState(7090) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserORDER { + { + p.SetState(7080) + p.Match(MySqlParserORDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7081) + p.Match(MySqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7082) + p.OrderByExpression() + } + p.SetState(7087) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(7083) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7084) + p.OrderByExpression() + } + + p.SetState(7089) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + p.SetState(7094) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserSEPARATOR { + { + p.SetState(7092) + p.Match(MySqlParserSEPARATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7093) + + var _m = p.Match(MySqlParserSTRING_LITERAL) + + localctx.(*AggregateWindowedFunctionContext).separator = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7096) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INonAggregateWindowedFunctionContext is an interface to support dynamic dispatch. +type INonAggregateWindowedFunctionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + Expression() IExpressionContext + RR_BRACKET() antlr.TerminalNode + OverClause() IOverClauseContext + LAG() antlr.TerminalNode + LEAD() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllDecimalLiteral() []IDecimalLiteralContext + DecimalLiteral(i int) IDecimalLiteralContext + FIRST_VALUE() antlr.TerminalNode + LAST_VALUE() antlr.TerminalNode + CUME_DIST() antlr.TerminalNode + DENSE_RANK() antlr.TerminalNode + PERCENT_RANK() antlr.TerminalNode + RANK() antlr.TerminalNode + ROW_NUMBER() antlr.TerminalNode + NTH_VALUE() antlr.TerminalNode + NTILE() antlr.TerminalNode + + // IsNonAggregateWindowedFunctionContext differentiates from other interfaces. + IsNonAggregateWindowedFunctionContext() +} + +type NonAggregateWindowedFunctionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNonAggregateWindowedFunctionContext() *NonAggregateWindowedFunctionContext { + var p = new(NonAggregateWindowedFunctionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_nonAggregateWindowedFunction + return p +} + +func InitEmptyNonAggregateWindowedFunctionContext(p *NonAggregateWindowedFunctionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_nonAggregateWindowedFunction +} + +func (*NonAggregateWindowedFunctionContext) IsNonAggregateWindowedFunctionContext() {} + +func NewNonAggregateWindowedFunctionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NonAggregateWindowedFunctionContext { + var p = new(NonAggregateWindowedFunctionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_nonAggregateWindowedFunction + + return p +} + +func (s *NonAggregateWindowedFunctionContext) GetParser() antlr.Parser { return s.parser } + +func (s *NonAggregateWindowedFunctionContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *NonAggregateWindowedFunctionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *NonAggregateWindowedFunctionContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *NonAggregateWindowedFunctionContext) OverClause() IOverClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOverClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOverClauseContext) +} + +func (s *NonAggregateWindowedFunctionContext) LAG() antlr.TerminalNode { + return s.GetToken(MySqlParserLAG, 0) +} + +func (s *NonAggregateWindowedFunctionContext) LEAD() antlr.TerminalNode { + return s.GetToken(MySqlParserLEAD, 0) +} + +func (s *NonAggregateWindowedFunctionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *NonAggregateWindowedFunctionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *NonAggregateWindowedFunctionContext) AllDecimalLiteral() []IDecimalLiteralContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDecimalLiteralContext); ok { + len++ + } + } + + tst := make([]IDecimalLiteralContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDecimalLiteralContext); ok { + tst[i] = t.(IDecimalLiteralContext) + i++ + } + } + + return tst +} + +func (s *NonAggregateWindowedFunctionContext) DecimalLiteral(i int) IDecimalLiteralContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *NonAggregateWindowedFunctionContext) FIRST_VALUE() antlr.TerminalNode { + return s.GetToken(MySqlParserFIRST_VALUE, 0) +} + +func (s *NonAggregateWindowedFunctionContext) LAST_VALUE() antlr.TerminalNode { + return s.GetToken(MySqlParserLAST_VALUE, 0) +} + +func (s *NonAggregateWindowedFunctionContext) CUME_DIST() antlr.TerminalNode { + return s.GetToken(MySqlParserCUME_DIST, 0) +} + +func (s *NonAggregateWindowedFunctionContext) DENSE_RANK() antlr.TerminalNode { + return s.GetToken(MySqlParserDENSE_RANK, 0) +} + +func (s *NonAggregateWindowedFunctionContext) PERCENT_RANK() antlr.TerminalNode { + return s.GetToken(MySqlParserPERCENT_RANK, 0) +} + +func (s *NonAggregateWindowedFunctionContext) RANK() antlr.TerminalNode { + return s.GetToken(MySqlParserRANK, 0) +} + +func (s *NonAggregateWindowedFunctionContext) ROW_NUMBER() antlr.TerminalNode { + return s.GetToken(MySqlParserROW_NUMBER, 0) +} + +func (s *NonAggregateWindowedFunctionContext) NTH_VALUE() antlr.TerminalNode { + return s.GetToken(MySqlParserNTH_VALUE, 0) +} + +func (s *NonAggregateWindowedFunctionContext) NTILE() antlr.TerminalNode { + return s.GetToken(MySqlParserNTILE, 0) +} + +func (s *NonAggregateWindowedFunctionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *NonAggregateWindowedFunctionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *NonAggregateWindowedFunctionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterNonAggregateWindowedFunction(s) + } +} + +func (s *NonAggregateWindowedFunctionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitNonAggregateWindowedFunction(s) + } +} + +func (p *MySqlParser) NonAggregateWindowedFunction() (localctx INonAggregateWindowedFunctionContext) { + localctx = NewNonAggregateWindowedFunctionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 660, MySqlParserRULE_nonAggregateWindowedFunction) + var _la int + + p.SetState(7138) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserLAG, MySqlParserLEAD: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7100) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserLAG || _la == MySqlParserLEAD) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(7101) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7102) + p.expression(0) + } + p.SetState(7105) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1059, p.GetParserRuleContext()) == 1 { + { + p.SetState(7103) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7104) + p.DecimalLiteral() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(7109) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserCOMMA { + { + p.SetState(7107) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7108) + p.DecimalLiteral() + } + + } + { + p.SetState(7111) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7112) + p.OverClause() + } + + case MySqlParserFIRST_VALUE, MySqlParserLAST_VALUE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7114) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserFIRST_VALUE || _la == MySqlParserLAST_VALUE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(7115) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7116) + p.expression(0) + } + { + p.SetState(7117) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7118) + p.OverClause() + } + + case MySqlParserCUME_DIST, MySqlParserDENSE_RANK, MySqlParserPERCENT_RANK, MySqlParserRANK, MySqlParserROW_NUMBER: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(7120) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-292)) & ^0x3f) == 0 && ((int64(1)<<(_la-292))&14339) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(7121) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7122) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7123) + p.OverClause() + } + + case MySqlParserNTH_VALUE: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(7124) + p.Match(MySqlParserNTH_VALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7125) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7126) + p.expression(0) + } + { + p.SetState(7127) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7128) + p.DecimalLiteral() + } + { + p.SetState(7129) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7130) + p.OverClause() + } + + case MySqlParserNTILE: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(7132) + p.Match(MySqlParserNTILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7133) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7134) + p.DecimalLiteral() + } + { + p.SetState(7135) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7136) + p.OverClause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOverClauseContext is an interface to support dynamic dispatch. +type IOverClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OVER() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + WindowSpec() IWindowSpecContext + RR_BRACKET() antlr.TerminalNode + WindowName() IWindowNameContext + + // IsOverClauseContext differentiates from other interfaces. + IsOverClauseContext() +} + +type OverClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOverClauseContext() *OverClauseContext { + var p = new(OverClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_overClause + return p +} + +func InitEmptyOverClauseContext(p *OverClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_overClause +} + +func (*OverClauseContext) IsOverClauseContext() {} + +func NewOverClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OverClauseContext { + var p = new(OverClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_overClause + + return p +} + +func (s *OverClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *OverClauseContext) OVER() antlr.TerminalNode { + return s.GetToken(MySqlParserOVER, 0) +} + +func (s *OverClauseContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *OverClauseContext) WindowSpec() IWindowSpecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWindowSpecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWindowSpecContext) +} + +func (s *OverClauseContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *OverClauseContext) WindowName() IWindowNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWindowNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWindowNameContext) +} + +func (s *OverClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *OverClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *OverClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterOverClause(s) + } +} + +func (s *OverClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitOverClause(s) + } +} + +func (p *MySqlParser) OverClause() (localctx IOverClauseContext) { + localctx = NewOverClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 662, MySqlParserRULE_overClause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7140) + p.Match(MySqlParserOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7146) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserLR_BRACKET: + { + p.SetState(7141) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7142) + p.WindowSpec() + } + { + p.SetState(7143) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserARRAY, MySqlParserATTRIBUTE, MySqlParserBUCKETS, MySqlParserCONDITION, MySqlParserCURRENT, MySqlParserCURRENT_USER, MySqlParserDATABASE, MySqlParserDEFAULT, MySqlParserDIAGNOSTICS, MySqlParserEMPTY, MySqlParserENFORCED, MySqlParserEXCEPT, MySqlParserGROUP, MySqlParserIF, MySqlParserIGNORED, MySqlParserINSERT, MySqlParserLATERAL, MySqlParserLEFT, MySqlParserNUMBER, MySqlParserOPTIONAL, MySqlParserORDER, MySqlParserPRIMARY, MySqlParserREPEAT, MySqlParserREPLACE, MySqlParserRIGHT, MySqlParserSCHEMA, MySqlParserSKIP_QUERY_REWRITE, MySqlParserSTACKED, MySqlParserSTATEMENT, MySqlParserDATE, MySqlParserTIME, MySqlParserTIMESTAMP, MySqlParserDATETIME, MySqlParserYEAR, MySqlParserBINARY, MySqlParserTEXT, MySqlParserENUM, MySqlParserSERIAL, MySqlParserJSON_ARRAY, MySqlParserJSON_ARRAYAGG, MySqlParserJSON_ARRAY_APPEND, MySqlParserJSON_ARRAY_INSERT, MySqlParserJSON_CONTAINS, MySqlParserJSON_CONTAINS_PATH, MySqlParserJSON_DEPTH, MySqlParserJSON_EXTRACT, MySqlParserJSON_INSERT, MySqlParserJSON_KEYS, MySqlParserJSON_LENGTH, MySqlParserJSON_MERGE, MySqlParserJSON_MERGE_PATCH, MySqlParserJSON_MERGE_PRESERVE, MySqlParserJSON_OBJECT, MySqlParserJSON_OBJECTAGG, MySqlParserJSON_OVERLAPS, MySqlParserJSON_PRETTY, MySqlParserJSON_QUOTE, MySqlParserJSON_REMOVE, MySqlParserJSON_REPLACE, MySqlParserJSON_SCHEMA_VALID, MySqlParserJSON_SCHEMA_VALIDATION_REPORT, MySqlParserJSON_SEARCH, MySqlParserJSON_SET, MySqlParserJSON_STORAGE_FREE, MySqlParserJSON_STORAGE_SIZE, MySqlParserJSON_TABLE, MySqlParserJSON_TYPE, MySqlParserJSON_UNQUOTE, MySqlParserJSON_VALID, MySqlParserJSON_VALUE, MySqlParserNESTED, MySqlParserORDINALITY, MySqlParserPATH, MySqlParserAVG, MySqlParserBIT_AND, MySqlParserBIT_OR, MySqlParserBIT_XOR, MySqlParserCOUNT, MySqlParserCUME_DIST, MySqlParserDENSE_RANK, MySqlParserFIRST_VALUE, MySqlParserGROUP_CONCAT, MySqlParserLAG, MySqlParserLAST_VALUE, MySqlParserLEAD, MySqlParserMAX, MySqlParserMIN, MySqlParserNTILE, MySqlParserNTH_VALUE, MySqlParserPERCENT_RANK, MySqlParserRANK, MySqlParserROW_NUMBER, MySqlParserSTD, MySqlParserSTDDEV, MySqlParserSTDDEV_POP, MySqlParserSTDDEV_SAMP, MySqlParserSUM, MySqlParserVAR_POP, MySqlParserVAR_SAMP, MySqlParserVARIANCE, MySqlParserCURRENT_DATE, MySqlParserCURRENT_TIME, MySqlParserCURRENT_TIMESTAMP, MySqlParserLOCALTIME, MySqlParserCURDATE, MySqlParserCURTIME, MySqlParserDATE_ADD, MySqlParserDATE_SUB, MySqlParserLOCALTIMESTAMP, MySqlParserNOW, MySqlParserPOSITION, MySqlParserSUBSTR, MySqlParserSUBSTRING, MySqlParserSYSDATE, MySqlParserTRIM, MySqlParserUTC_DATE, MySqlParserUTC_TIME, MySqlParserUTC_TIMESTAMP, MySqlParserACCOUNT, MySqlParserACTION, MySqlParserAFTER, MySqlParserAGGREGATE, MySqlParserALGORITHM, MySqlParserANY, MySqlParserAT, MySqlParserAUTHORS, MySqlParserAUTOCOMMIT, MySqlParserAUTOEXTEND_SIZE, MySqlParserAUTO_INCREMENT, MySqlParserAVG_ROW_LENGTH, MySqlParserBEGIN, MySqlParserBINLOG, MySqlParserBIT, MySqlParserBLOCK, MySqlParserBOOL, MySqlParserBOOLEAN, MySqlParserBTREE, MySqlParserCACHE, MySqlParserCASCADED, MySqlParserCHAIN, MySqlParserCHANGED, MySqlParserCHANNEL, MySqlParserCHECKSUM, MySqlParserPAGE_CHECKSUM, MySqlParserCIPHER, MySqlParserCLASS_ORIGIN, MySqlParserCLIENT, MySqlParserCLOSE, MySqlParserCLUSTERING, MySqlParserCOALESCE, MySqlParserCODE, MySqlParserCOLUMNS, MySqlParserCOLUMN_FORMAT, MySqlParserCOLUMN_NAME, MySqlParserCOMMENT, MySqlParserCOMMIT, MySqlParserCOMPACT, MySqlParserCOMPLETION, MySqlParserCOMPRESSED, MySqlParserCOMPRESSION, MySqlParserCONCURRENT, MySqlParserCONNECT, MySqlParserCONNECTION, MySqlParserCONSISTENT, MySqlParserCONSTRAINT_CATALOG, MySqlParserCONSTRAINT_SCHEMA, MySqlParserCONSTRAINT_NAME, MySqlParserCONTAINS, MySqlParserCONTEXT, MySqlParserCONTRIBUTORS, MySqlParserCOPY, MySqlParserCPU, MySqlParserCURSOR_NAME, MySqlParserDATA, MySqlParserDATAFILE, MySqlParserDEALLOCATE, MySqlParserDEFAULT_AUTH, MySqlParserDEFINER, MySqlParserDELAY_KEY_WRITE, MySqlParserDES_KEY_FILE, MySqlParserDIRECTORY, MySqlParserDISABLE, MySqlParserDISCARD, MySqlParserDISK, MySqlParserDO, MySqlParserDUMPFILE, MySqlParserDUPLICATE, MySqlParserDYNAMIC, MySqlParserENABLE, MySqlParserENCRYPTION, MySqlParserEND, MySqlParserENDS, MySqlParserENGINE, MySqlParserENGINES, MySqlParserERROR, MySqlParserERRORS, MySqlParserESCAPE, MySqlParserEVEN, MySqlParserEVENT, MySqlParserEVENTS, MySqlParserEVERY, MySqlParserEXCHANGE, MySqlParserEXCLUSIVE, MySqlParserEXPIRE, MySqlParserEXPORT, MySqlParserEXTENDED, MySqlParserEXTENT_SIZE, MySqlParserFAILED_LOGIN_ATTEMPTS, MySqlParserFAST, MySqlParserFAULTS, MySqlParserFIELDS, MySqlParserFILE_BLOCK_SIZE, MySqlParserFILTER, MySqlParserFIRST, MySqlParserFIXED, MySqlParserFLUSH, MySqlParserFOLLOWS, MySqlParserFOUND, MySqlParserFULL, MySqlParserFUNCTION, MySqlParserGENERAL, MySqlParserGLOBAL, MySqlParserGRANTS, MySqlParserGROUP_REPLICATION, MySqlParserHANDLER, MySqlParserHASH, MySqlParserHELP, MySqlParserHISTORY, MySqlParserHOST, MySqlParserHOSTS, MySqlParserIDENTIFIED, MySqlParserIGNORE_SERVER_IDS, MySqlParserIMPORT, MySqlParserINDEXES, MySqlParserINITIAL_SIZE, MySqlParserINPLACE, MySqlParserINSERT_METHOD, MySqlParserINSTALL, MySqlParserINSTANCE, MySqlParserINSTANT, MySqlParserINVISIBLE, MySqlParserINVOKER, MySqlParserIO, MySqlParserIO_THREAD, MySqlParserIPC, MySqlParserISOLATION, MySqlParserISSUER, MySqlParserJSON, MySqlParserKEY_BLOCK_SIZE, MySqlParserLANGUAGE, MySqlParserLAST, MySqlParserLEAVES, MySqlParserLESS, MySqlParserLEVEL, MySqlParserLIST, MySqlParserLOCAL, MySqlParserLOGFILE, MySqlParserLOGS, MySqlParserMASTER, MySqlParserMASTER_AUTO_POSITION, MySqlParserMASTER_CONNECT_RETRY, MySqlParserMASTER_DELAY, MySqlParserMASTER_HEARTBEAT_PERIOD, MySqlParserMASTER_HOST, MySqlParserMASTER_LOG_FILE, MySqlParserMASTER_LOG_POS, MySqlParserMASTER_PASSWORD, MySqlParserMASTER_PORT, MySqlParserMASTER_RETRY_COUNT, MySqlParserMASTER_SSL, MySqlParserMASTER_SSL_CA, MySqlParserMASTER_SSL_CAPATH, MySqlParserMASTER_SSL_CERT, MySqlParserMASTER_SSL_CIPHER, MySqlParserMASTER_SSL_CRL, MySqlParserMASTER_SSL_CRLPATH, MySqlParserMASTER_SSL_KEY, MySqlParserMASTER_TLS_VERSION, MySqlParserMASTER_USER, MySqlParserMAX_CONNECTIONS_PER_HOUR, MySqlParserMAX_QUERIES_PER_HOUR, MySqlParserMAX_ROWS, MySqlParserMAX_SIZE, MySqlParserMAX_UPDATES_PER_HOUR, MySqlParserMAX_USER_CONNECTIONS, MySqlParserMEDIUM, MySqlParserMEMBER, MySqlParserMERGE, MySqlParserMESSAGE_TEXT, MySqlParserMID, MySqlParserMIGRATE, MySqlParserMIN_ROWS, MySqlParserMODE, MySqlParserMODIFY, MySqlParserMUTEX, MySqlParserMYSQL, MySqlParserMYSQL_ERRNO, MySqlParserNAME, MySqlParserNAMES, MySqlParserNCHAR, MySqlParserNEVER, MySqlParserNEXT, MySqlParserNO, MySqlParserNOCOPY, MySqlParserNOWAIT, MySqlParserNODEGROUP, MySqlParserNONE, MySqlParserODBC, MySqlParserOFFLINE, MySqlParserOFFSET, MySqlParserOF, MySqlParserOJ, MySqlParserOLD_PASSWORD, MySqlParserONE, MySqlParserONLINE, MySqlParserONLY, MySqlParserOPEN, MySqlParserOPTIMIZER_COSTS, MySqlParserOPTIONS, MySqlParserOWNER, MySqlParserPACK_KEYS, MySqlParserPAGE, MySqlParserPARSER, MySqlParserPARTIAL, MySqlParserPARTITIONING, MySqlParserPARTITIONS, MySqlParserPASSWORD, MySqlParserPASSWORD_LOCK_TIME, MySqlParserPHASE, MySqlParserPLUGIN, MySqlParserPLUGIN_DIR, MySqlParserPLUGINS, MySqlParserPORT, MySqlParserPRECEDES, MySqlParserPREPARE, MySqlParserPRESERVE, MySqlParserPREV, MySqlParserPROCESSLIST, MySqlParserPROFILE, MySqlParserPROFILES, MySqlParserPROXY, MySqlParserQUERY, MySqlParserQUICK, MySqlParserREBUILD, MySqlParserRECOVER, MySqlParserRECURSIVE, MySqlParserREDO_BUFFER_SIZE, MySqlParserREDUNDANT, MySqlParserRELAY, MySqlParserRELAY_LOG_FILE, MySqlParserRELAY_LOG_POS, MySqlParserRELAYLOG, MySqlParserREMOVE, MySqlParserREORGANIZE, MySqlParserREPAIR, MySqlParserREPLICATE_DO_DB, MySqlParserREPLICATE_DO_TABLE, MySqlParserREPLICATE_IGNORE_DB, MySqlParserREPLICATE_IGNORE_TABLE, MySqlParserREPLICATE_REWRITE_DB, MySqlParserREPLICATE_WILD_DO_TABLE, MySqlParserREPLICATE_WILD_IGNORE_TABLE, MySqlParserREPLICATION, MySqlParserRESET, MySqlParserRESUME, MySqlParserRETURNED_SQLSTATE, MySqlParserRETURNING, MySqlParserRETURNS, MySqlParserREUSE, MySqlParserROLE, MySqlParserROLLBACK, MySqlParserROLLUP, MySqlParserROTATE, MySqlParserROW, MySqlParserROWS, MySqlParserROW_FORMAT, MySqlParserRTREE, MySqlParserSAVEPOINT, MySqlParserSCHEDULE, MySqlParserSECURITY, MySqlParserSERVER, MySqlParserSESSION, MySqlParserSHARE, MySqlParserSHARED, MySqlParserSIGNED, MySqlParserSIMPLE, MySqlParserSLAVE, MySqlParserSLOW, MySqlParserSNAPSHOT, MySqlParserSOCKET, MySqlParserSOME, MySqlParserSONAME, MySqlParserSOUNDS, MySqlParserSOURCE, MySqlParserSQL_AFTER_GTIDS, MySqlParserSQL_AFTER_MTS_GAPS, MySqlParserSQL_BEFORE_GTIDS, MySqlParserSQL_BUFFER_RESULT, MySqlParserSQL_CACHE, MySqlParserSQL_NO_CACHE, MySqlParserSQL_THREAD, MySqlParserSTART, MySqlParserSTARTS, MySqlParserSTATS_AUTO_RECALC, MySqlParserSTATS_PERSISTENT, MySqlParserSTATS_SAMPLE_PAGES, MySqlParserSTATUS, MySqlParserSTOP, MySqlParserSTORAGE, MySqlParserSTRING, MySqlParserSUBCLASS_ORIGIN, MySqlParserSUBJECT, MySqlParserSUBPARTITION, MySqlParserSUBPARTITIONS, MySqlParserSUSPEND, MySqlParserSWAPS, MySqlParserSWITCHES, MySqlParserTABLE_NAME, MySqlParserTABLESPACE, MySqlParserTABLE_TYPE, MySqlParserTEMPORARY, MySqlParserTEMPTABLE, MySqlParserTHAN, MySqlParserTRADITIONAL, MySqlParserTRANSACTION, MySqlParserTRANSACTIONAL, MySqlParserTRIGGERS, MySqlParserTRUNCATE, MySqlParserUNBOUNDED, MySqlParserUNDEFINED, MySqlParserUNDOFILE, MySqlParserUNDO_BUFFER_SIZE, MySqlParserUNINSTALL, MySqlParserUNKNOWN, MySqlParserUNTIL, MySqlParserUPGRADE, MySqlParserUSER, MySqlParserUSE_FRM, MySqlParserUSER_RESOURCES, MySqlParserVALIDATION, MySqlParserVALUE, MySqlParserVARIABLES, MySqlParserVIEW, MySqlParserVIRTUAL, MySqlParserVISIBLE, MySqlParserWAIT, MySqlParserWARNINGS, MySqlParserWITHOUT, MySqlParserWORK, MySqlParserWRAPPER, MySqlParserX509, MySqlParserXA, MySqlParserXML, MySqlParserYES, MySqlParserEUR, MySqlParserUSA, MySqlParserJIS, MySqlParserISO, MySqlParserINTERNAL, MySqlParserQUARTER, MySqlParserMONTH, MySqlParserDAY, MySqlParserHOUR, MySqlParserMINUTE, MySqlParserWEEK, MySqlParserSECOND, MySqlParserMICROSECOND, MySqlParserADMIN, MySqlParserAUDIT_ABORT_EXEMPT, MySqlParserAUDIT_ADMIN, MySqlParserAUTHENTICATION_POLICY_ADMIN, MySqlParserBACKUP_ADMIN, MySqlParserBINLOG_ADMIN, MySqlParserBINLOG_ENCRYPTION_ADMIN, MySqlParserCLONE_ADMIN, MySqlParserCONNECTION_ADMIN, MySqlParserENCRYPTION_KEY_ADMIN, MySqlParserEXECUTE, MySqlParserFILE, MySqlParserFIREWALL_ADMIN, MySqlParserFIREWALL_EXEMPT, MySqlParserFIREWALL_USER, MySqlParserGROUP_REPLICATION_ADMIN, MySqlParserINNODB_REDO_LOG_ARCHIVE, MySqlParserINVOKE, MySqlParserLAMBDA, MySqlParserNDB_STORED_USER, MySqlParserPASSWORDLESS_USER_ADMIN, MySqlParserPERSIST_RO_VARIABLES_ADMIN, MySqlParserPRIVILEGES, MySqlParserPROCESS, MySqlParserRELOAD, MySqlParserREPLICATION_APPLIER, MySqlParserREPLICATION_SLAVE_ADMIN, MySqlParserRESOURCE_GROUP_ADMIN, MySqlParserRESOURCE_GROUP_USER, MySqlParserROLE_ADMIN, MySqlParserROUTINE, MySqlParserS3, MySqlParserSESSION_VARIABLES_ADMIN, MySqlParserSET_USER_ID, MySqlParserSHOW_ROUTINE, MySqlParserSHUTDOWN, MySqlParserSUPER, MySqlParserSYSTEM_VARIABLES_ADMIN, MySqlParserTABLES, MySqlParserTABLE_ENCRYPTION_ADMIN, MySqlParserVERSION_TOKEN_ADMIN, MySqlParserXA_RECOVER_ADMIN, MySqlParserARMSCII8, MySqlParserASCII, MySqlParserBIG5, MySqlParserCP1250, MySqlParserCP1251, MySqlParserCP1256, MySqlParserCP1257, MySqlParserCP850, MySqlParserCP852, MySqlParserCP866, MySqlParserCP932, MySqlParserDEC8, MySqlParserEUCJPMS, MySqlParserEUCKR, MySqlParserGB18030, MySqlParserGB2312, MySqlParserGBK, MySqlParserGEOSTD8, MySqlParserGREEK, MySqlParserHEBREW, MySqlParserHP8, MySqlParserKEYBCS2, MySqlParserKOI8R, MySqlParserKOI8U, MySqlParserLATIN1, MySqlParserLATIN2, MySqlParserLATIN5, MySqlParserLATIN7, MySqlParserMACCE, MySqlParserMACROMAN, MySqlParserSJIS, MySqlParserSWE7, MySqlParserTIS620, MySqlParserUCS2, MySqlParserUJIS, MySqlParserUTF16, MySqlParserUTF16LE, MySqlParserUTF32, MySqlParserUTF8, MySqlParserUTF8MB3, MySqlParserUTF8MB4, MySqlParserARCHIVE, MySqlParserBLACKHOLE, MySqlParserCSV, MySqlParserFEDERATED, MySqlParserINNODB, MySqlParserMEMORY, MySqlParserMRG_MYISAM, MySqlParserMYISAM, MySqlParserNDB, MySqlParserNDBCLUSTER, MySqlParserPERFORMANCE_SCHEMA, MySqlParserTOKUDB, MySqlParserREPEATABLE, MySqlParserCOMMITTED, MySqlParserUNCOMMITTED, MySqlParserSERIALIZABLE, MySqlParserGEOMETRYCOLLECTION, MySqlParserLINESTRING, MySqlParserMULTILINESTRING, MySqlParserMULTIPOINT, MySqlParserMULTIPOLYGON, MySqlParserPOINT, MySqlParserPOLYGON, MySqlParserABS, MySqlParserACOS, MySqlParserADDDATE, MySqlParserADDTIME, MySqlParserAES_DECRYPT, MySqlParserAES_ENCRYPT, MySqlParserAREA, MySqlParserASBINARY, MySqlParserASIN, MySqlParserASTEXT, MySqlParserASWKB, MySqlParserASWKT, MySqlParserASYMMETRIC_DECRYPT, MySqlParserASYMMETRIC_DERIVE, MySqlParserASYMMETRIC_ENCRYPT, MySqlParserASYMMETRIC_SIGN, MySqlParserASYMMETRIC_VERIFY, MySqlParserATAN, MySqlParserATAN2, MySqlParserBENCHMARK, MySqlParserBIN, MySqlParserBIT_COUNT, MySqlParserBIT_LENGTH, MySqlParserBUFFER, MySqlParserCATALOG_NAME, MySqlParserCEIL, MySqlParserCEILING, MySqlParserCENTROID, MySqlParserCHARACTER_LENGTH, MySqlParserCHARSET, MySqlParserCHAR_LENGTH, MySqlParserCOERCIBILITY, MySqlParserCOLLATION, MySqlParserCOMPRESS, MySqlParserCONCAT, MySqlParserCONCAT_WS, MySqlParserCONNECTION_ID, MySqlParserCONV, MySqlParserCONVERT_TZ, MySqlParserCOS, MySqlParserCOT, MySqlParserCRC32, MySqlParserCREATE_ASYMMETRIC_PRIV_KEY, MySqlParserCREATE_ASYMMETRIC_PUB_KEY, MySqlParserCREATE_DH_PARAMETERS, MySqlParserCREATE_DIGEST, MySqlParserCROSSES, MySqlParserDATEDIFF, MySqlParserDATE_FORMAT, MySqlParserDAYNAME, MySqlParserDAYOFMONTH, MySqlParserDAYOFWEEK, MySqlParserDAYOFYEAR, MySqlParserDECODE, MySqlParserDEGREES, MySqlParserDES_DECRYPT, MySqlParserDES_ENCRYPT, MySqlParserDIMENSION, MySqlParserDISJOINT, MySqlParserDISTANCE, MySqlParserELT, MySqlParserENCODE, MySqlParserENCRYPT, MySqlParserENDPOINT, MySqlParserENGINE_ATTRIBUTE, MySqlParserENVELOPE, MySqlParserEQUALS, MySqlParserEXP, MySqlParserEXPORT_SET, MySqlParserEXTERIORRING, MySqlParserEXTRACTVALUE, MySqlParserFIELD, MySqlParserFIND_IN_SET, MySqlParserFLOOR, MySqlParserFORMAT, MySqlParserFOUND_ROWS, MySqlParserFROM_BASE64, MySqlParserFROM_DAYS, MySqlParserFROM_UNIXTIME, MySqlParserGEOMCOLLFROMTEXT, MySqlParserGEOMCOLLFROMWKB, MySqlParserGEOMETRYCOLLECTIONFROMTEXT, MySqlParserGEOMETRYCOLLECTIONFROMWKB, MySqlParserGEOMETRYFROMTEXT, MySqlParserGEOMETRYFROMWKB, MySqlParserGEOMETRYN, MySqlParserGEOMETRYTYPE, MySqlParserGEOMFROMTEXT, MySqlParserGEOMFROMWKB, MySqlParserGET_FORMAT, MySqlParserGET_LOCK, MySqlParserGLENGTH, MySqlParserGREATEST, MySqlParserGTID_SUBSET, MySqlParserGTID_SUBTRACT, MySqlParserHEX, MySqlParserIFNULL, MySqlParserINET6_ATON, MySqlParserINET6_NTOA, MySqlParserINET_ATON, MySqlParserINET_NTOA, MySqlParserINSTR, MySqlParserINTERIORRINGN, MySqlParserINTERSECTS, MySqlParserISCLOSED, MySqlParserISEMPTY, MySqlParserISNULL, MySqlParserISSIMPLE, MySqlParserIS_FREE_LOCK, MySqlParserIS_IPV4, MySqlParserIS_IPV4_COMPAT, MySqlParserIS_IPV4_MAPPED, MySqlParserIS_IPV6, MySqlParserIS_USED_LOCK, MySqlParserLAST_INSERT_ID, MySqlParserLCASE, MySqlParserLEAST, MySqlParserLENGTH, MySqlParserLINEFROMTEXT, MySqlParserLINEFROMWKB, MySqlParserLINESTRINGFROMTEXT, MySqlParserLINESTRINGFROMWKB, MySqlParserLN, MySqlParserLOAD_FILE, MySqlParserLOCATE, MySqlParserLOG, MySqlParserLOG10, MySqlParserLOG2, MySqlParserLOWER, MySqlParserLPAD, MySqlParserLTRIM, MySqlParserMAKEDATE, MySqlParserMAKETIME, MySqlParserMAKE_SET, MySqlParserMASTER_POS_WAIT, MySqlParserMBRCONTAINS, MySqlParserMBRDISJOINT, MySqlParserMBREQUAL, MySqlParserMBRINTERSECTS, MySqlParserMBROVERLAPS, MySqlParserMBRTOUCHES, MySqlParserMBRWITHIN, MySqlParserMD5, MySqlParserMLINEFROMTEXT, MySqlParserMLINEFROMWKB, MySqlParserMONTHNAME, MySqlParserMPOINTFROMTEXT, MySqlParserMPOINTFROMWKB, MySqlParserMPOLYFROMTEXT, MySqlParserMPOLYFROMWKB, MySqlParserMULTILINESTRINGFROMTEXT, MySqlParserMULTILINESTRINGFROMWKB, MySqlParserMULTIPOINTFROMTEXT, MySqlParserMULTIPOINTFROMWKB, MySqlParserMULTIPOLYGONFROMTEXT, MySqlParserMULTIPOLYGONFROMWKB, MySqlParserNAME_CONST, MySqlParserNULLIF, MySqlParserNUMGEOMETRIES, MySqlParserNUMINTERIORRINGS, MySqlParserNUMPOINTS, MySqlParserOCT, MySqlParserOCTET_LENGTH, MySqlParserORD, MySqlParserOVERLAPS, MySqlParserPERIOD_ADD, MySqlParserPERIOD_DIFF, MySqlParserPI, MySqlParserPOINTFROMTEXT, MySqlParserPOINTFROMWKB, MySqlParserPOINTN, MySqlParserPOLYFROMTEXT, MySqlParserPOLYFROMWKB, MySqlParserPOLYGONFROMTEXT, MySqlParserPOLYGONFROMWKB, MySqlParserPOW, MySqlParserPOWER, MySqlParserQUOTE, MySqlParserRADIANS, MySqlParserRAND, MySqlParserRANDOM, MySqlParserRANDOM_BYTES, MySqlParserRELEASE_LOCK, MySqlParserREVERSE, MySqlParserROUND, MySqlParserROW_COUNT, MySqlParserRPAD, MySqlParserRTRIM, MySqlParserSEC_TO_TIME, MySqlParserSECONDARY_ENGINE_ATTRIBUTE, MySqlParserSESSION_USER, MySqlParserSHA, MySqlParserSHA1, MySqlParserSHA2, MySqlParserSCHEMA_NAME, MySqlParserSIGN, MySqlParserSIN, MySqlParserSLEEP, MySqlParserSOUNDEX, MySqlParserSQL_THREAD_WAIT_AFTER_GTIDS, MySqlParserSQRT, MySqlParserSRID, MySqlParserSTARTPOINT, MySqlParserSTRCMP, MySqlParserSTR_TO_DATE, MySqlParserST_AREA, MySqlParserST_ASBINARY, MySqlParserST_ASTEXT, MySqlParserST_ASWKB, MySqlParserST_ASWKT, MySqlParserST_BUFFER, MySqlParserST_CENTROID, MySqlParserST_CONTAINS, MySqlParserST_CROSSES, MySqlParserST_DIFFERENCE, MySqlParserST_DIMENSION, MySqlParserST_DISJOINT, MySqlParserST_DISTANCE, MySqlParserST_ENDPOINT, MySqlParserST_ENVELOPE, MySqlParserST_EQUALS, MySqlParserST_EXTERIORRING, MySqlParserST_GEOMCOLLFROMTEXT, MySqlParserST_GEOMCOLLFROMTXT, MySqlParserST_GEOMCOLLFROMWKB, MySqlParserST_GEOMETRYCOLLECTIONFROMTEXT, MySqlParserST_GEOMETRYCOLLECTIONFROMWKB, MySqlParserST_GEOMETRYFROMTEXT, MySqlParserST_GEOMETRYFROMWKB, MySqlParserST_GEOMETRYN, MySqlParserST_GEOMETRYTYPE, MySqlParserST_GEOMFROMTEXT, MySqlParserST_GEOMFROMWKB, MySqlParserST_INTERIORRINGN, MySqlParserST_INTERSECTION, MySqlParserST_INTERSECTS, MySqlParserST_ISCLOSED, MySqlParserST_ISEMPTY, MySqlParserST_ISSIMPLE, MySqlParserST_LINEFROMTEXT, MySqlParserST_LINEFROMWKB, MySqlParserST_LINESTRINGFROMTEXT, MySqlParserST_LINESTRINGFROMWKB, MySqlParserST_NUMGEOMETRIES, MySqlParserST_NUMINTERIORRING, MySqlParserST_NUMINTERIORRINGS, MySqlParserST_NUMPOINTS, MySqlParserST_OVERLAPS, MySqlParserST_POINTFROMTEXT, MySqlParserST_POINTFROMWKB, MySqlParserST_POINTN, MySqlParserST_POLYFROMTEXT, MySqlParserST_POLYFROMWKB, MySqlParserST_POLYGONFROMTEXT, MySqlParserST_POLYGONFROMWKB, MySqlParserST_SRID, MySqlParserST_STARTPOINT, MySqlParserST_SYMDIFFERENCE, MySqlParserST_TOUCHES, MySqlParserST_UNION, MySqlParserST_WITHIN, MySqlParserST_X, MySqlParserST_Y, MySqlParserSTRING_TO_VECTOR, MySqlParserSUBDATE, MySqlParserSUBSTRING_INDEX, MySqlParserSUBTIME, MySqlParserSYSTEM_USER, MySqlParserTAN, MySqlParserTIMEDIFF, MySqlParserTIMESTAMPADD, MySqlParserTIMESTAMPDIFF, MySqlParserTIME_FORMAT, MySqlParserTIME_TO_SEC, MySqlParserTOUCHES, MySqlParserTO_BASE64, MySqlParserTO_DAYS, MySqlParserTO_SECONDS, MySqlParserTP_CONNECTION_ADMIN, MySqlParserUCASE, MySqlParserUNCOMPRESS, MySqlParserUNCOMPRESSED_LENGTH, MySqlParserUNHEX, MySqlParserUNIX_TIMESTAMP, MySqlParserUPDATEXML, MySqlParserUPPER, MySqlParserUUID, MySqlParserUUID_SHORT, MySqlParserVALIDATE_PASSWORD_STRENGTH, MySqlParserVECTOR_DIM, MySqlParserVECTOR_TO_STRING, MySqlParserVERSION, MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS, MySqlParserWEEKDAY, MySqlParserWEEKOFYEAR, MySqlParserWEIGHT_STRING, MySqlParserWITHIN, MySqlParserYEARWEEK, MySqlParserY_FUNCTION, MySqlParserX_FUNCTION, MySqlParserMOD, MySqlParserCHARSET_REVERSE_QOUTE_STRING, MySqlParserSTRING_LITERAL, MySqlParserID: + { + p.SetState(7145) + p.WindowName() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWindowSpecContext is an interface to support dynamic dispatch. +type IWindowSpecContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WindowName() IWindowNameContext + PartitionClause() IPartitionClauseContext + OrderByClause() IOrderByClauseContext + FrameClause() IFrameClauseContext + + // IsWindowSpecContext differentiates from other interfaces. + IsWindowSpecContext() +} + +type WindowSpecContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWindowSpecContext() *WindowSpecContext { + var p = new(WindowSpecContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_windowSpec + return p +} + +func InitEmptyWindowSpecContext(p *WindowSpecContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_windowSpec +} + +func (*WindowSpecContext) IsWindowSpecContext() {} + +func NewWindowSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WindowSpecContext { + var p = new(WindowSpecContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_windowSpec + + return p +} + +func (s *WindowSpecContext) GetParser() antlr.Parser { return s.parser } + +func (s *WindowSpecContext) WindowName() IWindowNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWindowNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWindowNameContext) +} + +func (s *WindowSpecContext) PartitionClause() IPartitionClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartitionClauseContext) +} + +func (s *WindowSpecContext) OrderByClause() IOrderByClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOrderByClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOrderByClauseContext) +} + +func (s *WindowSpecContext) FrameClause() IFrameClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFrameClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFrameClauseContext) +} + +func (s *WindowSpecContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *WindowSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *WindowSpecContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterWindowSpec(s) + } +} + +func (s *WindowSpecContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitWindowSpec(s) + } +} + +func (p *MySqlParser) WindowSpec() (localctx IWindowSpecContext) { + localctx = NewWindowSpecContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 664, MySqlParserRULE_windowSpec) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(7149) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1063, p.GetParserRuleContext()) == 1 { + { + p.SetState(7148) + p.WindowName() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(7152) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserPARTITION { + { + p.SetState(7151) + p.PartitionClause() + } + + } + p.SetState(7155) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserORDER { + { + p.SetState(7154) + p.OrderByClause() + } + + } + p.SetState(7158) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserRANGE || _la == MySqlParserROWS { + { + p.SetState(7157) + p.FrameClause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWindowNameContext is an interface to support dynamic dispatch. +type IWindowNameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Uid() IUidContext + + // IsWindowNameContext differentiates from other interfaces. + IsWindowNameContext() +} + +type WindowNameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWindowNameContext() *WindowNameContext { + var p = new(WindowNameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_windowName + return p +} + +func InitEmptyWindowNameContext(p *WindowNameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_windowName +} + +func (*WindowNameContext) IsWindowNameContext() {} + +func NewWindowNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WindowNameContext { + var p = new(WindowNameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_windowName + + return p +} + +func (s *WindowNameContext) GetParser() antlr.Parser { return s.parser } + +func (s *WindowNameContext) Uid() IUidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUidContext) +} + +func (s *WindowNameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *WindowNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *WindowNameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterWindowName(s) + } +} + +func (s *WindowNameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitWindowName(s) + } +} + +func (p *MySqlParser) WindowName() (localctx IWindowNameContext) { + localctx = NewWindowNameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 666, MySqlParserRULE_windowName) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7160) + p.Uid() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFrameClauseContext is an interface to support dynamic dispatch. +type IFrameClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FrameUnits() IFrameUnitsContext + FrameExtent() IFrameExtentContext + + // IsFrameClauseContext differentiates from other interfaces. + IsFrameClauseContext() +} + +type FrameClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFrameClauseContext() *FrameClauseContext { + var p = new(FrameClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_frameClause + return p +} + +func InitEmptyFrameClauseContext(p *FrameClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_frameClause +} + +func (*FrameClauseContext) IsFrameClauseContext() {} + +func NewFrameClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FrameClauseContext { + var p = new(FrameClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_frameClause + + return p +} + +func (s *FrameClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *FrameClauseContext) FrameUnits() IFrameUnitsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFrameUnitsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFrameUnitsContext) +} + +func (s *FrameClauseContext) FrameExtent() IFrameExtentContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFrameExtentContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFrameExtentContext) +} + +func (s *FrameClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FrameClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FrameClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterFrameClause(s) + } +} + +func (s *FrameClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitFrameClause(s) + } +} + +func (p *MySqlParser) FrameClause() (localctx IFrameClauseContext) { + localctx = NewFrameClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 668, MySqlParserRULE_frameClause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7162) + p.FrameUnits() + } + { + p.SetState(7163) + p.FrameExtent() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFrameUnitsContext is an interface to support dynamic dispatch. +type IFrameUnitsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ROWS() antlr.TerminalNode + RANGE() antlr.TerminalNode + + // IsFrameUnitsContext differentiates from other interfaces. + IsFrameUnitsContext() +} + +type FrameUnitsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFrameUnitsContext() *FrameUnitsContext { + var p = new(FrameUnitsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_frameUnits + return p +} + +func InitEmptyFrameUnitsContext(p *FrameUnitsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_frameUnits +} + +func (*FrameUnitsContext) IsFrameUnitsContext() {} + +func NewFrameUnitsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FrameUnitsContext { + var p = new(FrameUnitsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_frameUnits + + return p +} + +func (s *FrameUnitsContext) GetParser() antlr.Parser { return s.parser } + +func (s *FrameUnitsContext) ROWS() antlr.TerminalNode { + return s.GetToken(MySqlParserROWS, 0) +} + +func (s *FrameUnitsContext) RANGE() antlr.TerminalNode { + return s.GetToken(MySqlParserRANGE, 0) +} + +func (s *FrameUnitsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FrameUnitsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FrameUnitsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterFrameUnits(s) + } +} + +func (s *FrameUnitsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitFrameUnits(s) + } +} + +func (p *MySqlParser) FrameUnits() (localctx IFrameUnitsContext) { + localctx = NewFrameUnitsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 670, MySqlParserRULE_frameUnits) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7165) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserRANGE || _la == MySqlParserROWS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFrameExtentContext is an interface to support dynamic dispatch. +type IFrameExtentContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FrameRange() IFrameRangeContext + FrameBetween() IFrameBetweenContext + + // IsFrameExtentContext differentiates from other interfaces. + IsFrameExtentContext() +} + +type FrameExtentContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFrameExtentContext() *FrameExtentContext { + var p = new(FrameExtentContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_frameExtent + return p +} + +func InitEmptyFrameExtentContext(p *FrameExtentContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_frameExtent +} + +func (*FrameExtentContext) IsFrameExtentContext() {} + +func NewFrameExtentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FrameExtentContext { + var p = new(FrameExtentContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_frameExtent + + return p +} + +func (s *FrameExtentContext) GetParser() antlr.Parser { return s.parser } + +func (s *FrameExtentContext) FrameRange() IFrameRangeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFrameRangeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFrameRangeContext) +} + +func (s *FrameExtentContext) FrameBetween() IFrameBetweenContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFrameBetweenContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFrameBetweenContext) +} + +func (s *FrameExtentContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FrameExtentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FrameExtentContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterFrameExtent(s) + } +} + +func (s *FrameExtentContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitFrameExtent(s) + } +} + +func (p *MySqlParser) FrameExtent() (localctx IFrameExtentContext) { + localctx = NewFrameExtentContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 672, MySqlParserRULE_frameExtent) + p.SetState(7169) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1067, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7167) + p.FrameRange() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7168) + p.FrameBetween() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFrameBetweenContext is an interface to support dynamic dispatch. +type IFrameBetweenContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BETWEEN() antlr.TerminalNode + AllFrameRange() []IFrameRangeContext + FrameRange(i int) IFrameRangeContext + AND() antlr.TerminalNode + + // IsFrameBetweenContext differentiates from other interfaces. + IsFrameBetweenContext() +} + +type FrameBetweenContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFrameBetweenContext() *FrameBetweenContext { + var p = new(FrameBetweenContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_frameBetween + return p +} + +func InitEmptyFrameBetweenContext(p *FrameBetweenContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_frameBetween +} + +func (*FrameBetweenContext) IsFrameBetweenContext() {} + +func NewFrameBetweenContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FrameBetweenContext { + var p = new(FrameBetweenContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_frameBetween + + return p +} + +func (s *FrameBetweenContext) GetParser() antlr.Parser { return s.parser } + +func (s *FrameBetweenContext) BETWEEN() antlr.TerminalNode { + return s.GetToken(MySqlParserBETWEEN, 0) +} + +func (s *FrameBetweenContext) AllFrameRange() []IFrameRangeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFrameRangeContext); ok { + len++ + } + } + + tst := make([]IFrameRangeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFrameRangeContext); ok { + tst[i] = t.(IFrameRangeContext) + i++ + } + } + + return tst +} + +func (s *FrameBetweenContext) FrameRange(i int) IFrameRangeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFrameRangeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFrameRangeContext) +} + +func (s *FrameBetweenContext) AND() antlr.TerminalNode { + return s.GetToken(MySqlParserAND, 0) +} + +func (s *FrameBetweenContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FrameBetweenContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FrameBetweenContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterFrameBetween(s) + } +} + +func (s *FrameBetweenContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitFrameBetween(s) + } +} + +func (p *MySqlParser) FrameBetween() (localctx IFrameBetweenContext) { + localctx = NewFrameBetweenContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 674, MySqlParserRULE_frameBetween) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7171) + p.Match(MySqlParserBETWEEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7172) + p.FrameRange() + } + { + p.SetState(7173) + p.Match(MySqlParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7174) + p.FrameRange() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFrameRangeContext is an interface to support dynamic dispatch. +type IFrameRangeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CURRENT() antlr.TerminalNode + ROW() antlr.TerminalNode + UNBOUNDED() antlr.TerminalNode + PRECEDING() antlr.TerminalNode + FOLLOWING() antlr.TerminalNode + Expression() IExpressionContext + + // IsFrameRangeContext differentiates from other interfaces. + IsFrameRangeContext() +} + +type FrameRangeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFrameRangeContext() *FrameRangeContext { + var p = new(FrameRangeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_frameRange + return p +} + +func InitEmptyFrameRangeContext(p *FrameRangeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_frameRange +} + +func (*FrameRangeContext) IsFrameRangeContext() {} + +func NewFrameRangeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FrameRangeContext { + var p = new(FrameRangeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_frameRange + + return p +} + +func (s *FrameRangeContext) GetParser() antlr.Parser { return s.parser } + +func (s *FrameRangeContext) CURRENT() antlr.TerminalNode { + return s.GetToken(MySqlParserCURRENT, 0) +} + +func (s *FrameRangeContext) ROW() antlr.TerminalNode { + return s.GetToken(MySqlParserROW, 0) +} + +func (s *FrameRangeContext) UNBOUNDED() antlr.TerminalNode { + return s.GetToken(MySqlParserUNBOUNDED, 0) +} + +func (s *FrameRangeContext) PRECEDING() antlr.TerminalNode { + return s.GetToken(MySqlParserPRECEDING, 0) +} + +func (s *FrameRangeContext) FOLLOWING() antlr.TerminalNode { + return s.GetToken(MySqlParserFOLLOWING, 0) +} + +func (s *FrameRangeContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *FrameRangeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FrameRangeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FrameRangeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterFrameRange(s) + } +} + +func (s *FrameRangeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitFrameRange(s) + } +} + +func (p *MySqlParser) FrameRange() (localctx IFrameRangeContext) { + localctx = NewFrameRangeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 676, MySqlParserRULE_frameRange) + var _la int + + p.SetState(7183) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1068, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7176) + p.Match(MySqlParserCURRENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7177) + p.Match(MySqlParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7178) + p.Match(MySqlParserUNBOUNDED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7179) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserFOLLOWING || _la == MySqlParserPRECEDING) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(7180) + p.expression(0) + } + { + p.SetState(7181) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserFOLLOWING || _la == MySqlParserPRECEDING) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPartitionClauseContext is an interface to support dynamic dispatch. +type IPartitionClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITION() antlr.TerminalNode + BY() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsPartitionClauseContext differentiates from other interfaces. + IsPartitionClauseContext() +} + +type PartitionClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPartitionClauseContext() *PartitionClauseContext { + var p = new(PartitionClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_partitionClause + return p +} + +func InitEmptyPartitionClauseContext(p *PartitionClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_partitionClause +} + +func (*PartitionClauseContext) IsPartitionClauseContext() {} + +func NewPartitionClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PartitionClauseContext { + var p = new(PartitionClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_partitionClause + + return p +} + +func (s *PartitionClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *PartitionClauseContext) PARTITION() antlr.TerminalNode { + return s.GetToken(MySqlParserPARTITION, 0) +} + +func (s *PartitionClauseContext) BY() antlr.TerminalNode { + return s.GetToken(MySqlParserBY, 0) +} + +func (s *PartitionClauseContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *PartitionClauseContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *PartitionClauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *PartitionClauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *PartitionClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PartitionClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PartitionClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterPartitionClause(s) + } +} + +func (s *PartitionClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitPartitionClause(s) + } +} + +func (p *MySqlParser) PartitionClause() (localctx IPartitionClauseContext) { + localctx = NewPartitionClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 678, MySqlParserRULE_partitionClause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7185) + p.Match(MySqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7186) + p.Match(MySqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7187) + p.expression(0) + } + p.SetState(7192) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(7188) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7189) + p.expression(0) + } + + p.SetState(7194) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IScalarFunctionNameContext is an interface to support dynamic dispatch. +type IScalarFunctionNameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FunctionNameBase() IFunctionNameBaseContext + ASCII() antlr.TerminalNode + CURDATE() antlr.TerminalNode + CURRENT_DATE() antlr.TerminalNode + CURRENT_TIME() antlr.TerminalNode + CURRENT_TIMESTAMP() antlr.TerminalNode + CURTIME() antlr.TerminalNode + DATE_ADD() antlr.TerminalNode + DATE_SUB() antlr.TerminalNode + IF() antlr.TerminalNode + INSERT() antlr.TerminalNode + LOCALTIME() antlr.TerminalNode + LOCALTIMESTAMP() antlr.TerminalNode + MID() antlr.TerminalNode + NOW() antlr.TerminalNode + REPEAT() antlr.TerminalNode + REPLACE() antlr.TerminalNode + SUBSTR() antlr.TerminalNode + SUBSTRING() antlr.TerminalNode + SYSDATE() antlr.TerminalNode + TRIM() antlr.TerminalNode + UTC_DATE() antlr.TerminalNode + UTC_TIME() antlr.TerminalNode + UTC_TIMESTAMP() antlr.TerminalNode + + // IsScalarFunctionNameContext differentiates from other interfaces. + IsScalarFunctionNameContext() +} + +type ScalarFunctionNameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyScalarFunctionNameContext() *ScalarFunctionNameContext { + var p = new(ScalarFunctionNameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_scalarFunctionName + return p +} + +func InitEmptyScalarFunctionNameContext(p *ScalarFunctionNameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_scalarFunctionName +} + +func (*ScalarFunctionNameContext) IsScalarFunctionNameContext() {} + +func NewScalarFunctionNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ScalarFunctionNameContext { + var p = new(ScalarFunctionNameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_scalarFunctionName + + return p +} + +func (s *ScalarFunctionNameContext) GetParser() antlr.Parser { return s.parser } + +func (s *ScalarFunctionNameContext) FunctionNameBase() IFunctionNameBaseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionNameBaseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunctionNameBaseContext) +} + +func (s *ScalarFunctionNameContext) ASCII() antlr.TerminalNode { + return s.GetToken(MySqlParserASCII, 0) +} + +func (s *ScalarFunctionNameContext) CURDATE() antlr.TerminalNode { + return s.GetToken(MySqlParserCURDATE, 0) +} + +func (s *ScalarFunctionNameContext) CURRENT_DATE() antlr.TerminalNode { + return s.GetToken(MySqlParserCURRENT_DATE, 0) +} + +func (s *ScalarFunctionNameContext) CURRENT_TIME() antlr.TerminalNode { + return s.GetToken(MySqlParserCURRENT_TIME, 0) +} + +func (s *ScalarFunctionNameContext) CURRENT_TIMESTAMP() antlr.TerminalNode { + return s.GetToken(MySqlParserCURRENT_TIMESTAMP, 0) +} + +func (s *ScalarFunctionNameContext) CURTIME() antlr.TerminalNode { + return s.GetToken(MySqlParserCURTIME, 0) +} + +func (s *ScalarFunctionNameContext) DATE_ADD() antlr.TerminalNode { + return s.GetToken(MySqlParserDATE_ADD, 0) +} + +func (s *ScalarFunctionNameContext) DATE_SUB() antlr.TerminalNode { + return s.GetToken(MySqlParserDATE_SUB, 0) +} + +func (s *ScalarFunctionNameContext) IF() antlr.TerminalNode { + return s.GetToken(MySqlParserIF, 0) +} + +func (s *ScalarFunctionNameContext) INSERT() antlr.TerminalNode { + return s.GetToken(MySqlParserINSERT, 0) +} + +func (s *ScalarFunctionNameContext) LOCALTIME() antlr.TerminalNode { + return s.GetToken(MySqlParserLOCALTIME, 0) +} + +func (s *ScalarFunctionNameContext) LOCALTIMESTAMP() antlr.TerminalNode { + return s.GetToken(MySqlParserLOCALTIMESTAMP, 0) +} + +func (s *ScalarFunctionNameContext) MID() antlr.TerminalNode { + return s.GetToken(MySqlParserMID, 0) +} + +func (s *ScalarFunctionNameContext) NOW() antlr.TerminalNode { + return s.GetToken(MySqlParserNOW, 0) +} + +func (s *ScalarFunctionNameContext) REPEAT() antlr.TerminalNode { + return s.GetToken(MySqlParserREPEAT, 0) +} + +func (s *ScalarFunctionNameContext) REPLACE() antlr.TerminalNode { + return s.GetToken(MySqlParserREPLACE, 0) +} + +func (s *ScalarFunctionNameContext) SUBSTR() antlr.TerminalNode { + return s.GetToken(MySqlParserSUBSTR, 0) +} + +func (s *ScalarFunctionNameContext) SUBSTRING() antlr.TerminalNode { + return s.GetToken(MySqlParserSUBSTRING, 0) +} + +func (s *ScalarFunctionNameContext) SYSDATE() antlr.TerminalNode { + return s.GetToken(MySqlParserSYSDATE, 0) +} + +func (s *ScalarFunctionNameContext) TRIM() antlr.TerminalNode { + return s.GetToken(MySqlParserTRIM, 0) +} + +func (s *ScalarFunctionNameContext) UTC_DATE() antlr.TerminalNode { + return s.GetToken(MySqlParserUTC_DATE, 0) +} + +func (s *ScalarFunctionNameContext) UTC_TIME() antlr.TerminalNode { + return s.GetToken(MySqlParserUTC_TIME, 0) +} + +func (s *ScalarFunctionNameContext) UTC_TIMESTAMP() antlr.TerminalNode { + return s.GetToken(MySqlParserUTC_TIMESTAMP, 0) +} + +func (s *ScalarFunctionNameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ScalarFunctionNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ScalarFunctionNameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterScalarFunctionName(s) + } +} + +func (s *ScalarFunctionNameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitScalarFunctionName(s) + } +} + +func (p *MySqlParser) ScalarFunctionName() (localctx IScalarFunctionNameContext) { + localctx = NewScalarFunctionNameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 680, MySqlParserRULE_scalarFunctionName) + p.SetState(7219) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserDATABASE, MySqlParserLEFT, MySqlParserRIGHT, MySqlParserSCHEMA, MySqlParserSTATEMENT, MySqlParserDATE, MySqlParserTIME, MySqlParserTIMESTAMP, MySqlParserYEAR, MySqlParserJSON_ARRAY, MySqlParserJSON_ARRAYAGG, MySqlParserJSON_ARRAY_APPEND, MySqlParserJSON_ARRAY_INSERT, MySqlParserJSON_CONTAINS, MySqlParserJSON_CONTAINS_PATH, MySqlParserJSON_DEPTH, MySqlParserJSON_EXTRACT, MySqlParserJSON_INSERT, MySqlParserJSON_KEYS, MySqlParserJSON_LENGTH, MySqlParserJSON_MERGE, MySqlParserJSON_MERGE_PATCH, MySqlParserJSON_MERGE_PRESERVE, MySqlParserJSON_OBJECT, MySqlParserJSON_OBJECTAGG, MySqlParserJSON_OVERLAPS, MySqlParserJSON_PRETTY, MySqlParserJSON_QUOTE, MySqlParserJSON_REMOVE, MySqlParserJSON_REPLACE, MySqlParserJSON_SCHEMA_VALID, MySqlParserJSON_SCHEMA_VALIDATION_REPORT, MySqlParserJSON_SEARCH, MySqlParserJSON_SET, MySqlParserJSON_STORAGE_FREE, MySqlParserJSON_STORAGE_SIZE, MySqlParserJSON_TABLE, MySqlParserJSON_TYPE, MySqlParserJSON_UNQUOTE, MySqlParserJSON_VALID, MySqlParserJSON_VALUE, MySqlParserCOUNT, MySqlParserCUME_DIST, MySqlParserDENSE_RANK, MySqlParserFIRST_VALUE, MySqlParserLAG, MySqlParserLAST_VALUE, MySqlParserLEAD, MySqlParserNTILE, MySqlParserNTH_VALUE, MySqlParserPERCENT_RANK, MySqlParserRANK, MySqlParserROW_NUMBER, MySqlParserPOSITION, MySqlParserINVISIBLE, MySqlParserVISIBLE, MySqlParserQUARTER, MySqlParserMONTH, MySqlParserDAY, MySqlParserHOUR, MySqlParserMINUTE, MySqlParserWEEK, MySqlParserSECOND, MySqlParserMICROSECOND, MySqlParserSESSION_VARIABLES_ADMIN, MySqlParserGEOMETRYCOLLECTION, MySqlParserLINESTRING, MySqlParserMULTILINESTRING, MySqlParserMULTIPOINT, MySqlParserMULTIPOLYGON, MySqlParserPOINT, MySqlParserPOLYGON, MySqlParserABS, MySqlParserACOS, MySqlParserADDDATE, MySqlParserADDTIME, MySqlParserAES_DECRYPT, MySqlParserAES_ENCRYPT, MySqlParserAREA, MySqlParserASBINARY, MySqlParserASIN, MySqlParserASTEXT, MySqlParserASWKB, MySqlParserASWKT, MySqlParserASYMMETRIC_DECRYPT, MySqlParserASYMMETRIC_DERIVE, MySqlParserASYMMETRIC_ENCRYPT, MySqlParserASYMMETRIC_SIGN, MySqlParserASYMMETRIC_VERIFY, MySqlParserATAN, MySqlParserATAN2, MySqlParserBENCHMARK, MySqlParserBIN, MySqlParserBIT_COUNT, MySqlParserBIT_LENGTH, MySqlParserBUFFER, MySqlParserCEIL, MySqlParserCEILING, MySqlParserCENTROID, MySqlParserCHARACTER_LENGTH, MySqlParserCHARSET, MySqlParserCHAR_LENGTH, MySqlParserCOERCIBILITY, MySqlParserCOLLATION, MySqlParserCOMPRESS, MySqlParserCONCAT, MySqlParserCONCAT_WS, MySqlParserCONNECTION_ID, MySqlParserCONV, MySqlParserCONVERT_TZ, MySqlParserCOS, MySqlParserCOT, MySqlParserCRC32, MySqlParserCREATE_ASYMMETRIC_PRIV_KEY, MySqlParserCREATE_ASYMMETRIC_PUB_KEY, MySqlParserCREATE_DH_PARAMETERS, MySqlParserCREATE_DIGEST, MySqlParserCROSSES, MySqlParserDATEDIFF, MySqlParserDATE_FORMAT, MySqlParserDAYNAME, MySqlParserDAYOFMONTH, MySqlParserDAYOFWEEK, MySqlParserDAYOFYEAR, MySqlParserDECODE, MySqlParserDEGREES, MySqlParserDES_DECRYPT, MySqlParserDES_ENCRYPT, MySqlParserDIMENSION, MySqlParserDISJOINT, MySqlParserDISTANCE, MySqlParserELT, MySqlParserENCODE, MySqlParserENCRYPT, MySqlParserENDPOINT, MySqlParserENVELOPE, MySqlParserEQUALS, MySqlParserEXP, MySqlParserEXPORT_SET, MySqlParserEXTERIORRING, MySqlParserEXTRACTVALUE, MySqlParserFIELD, MySqlParserFIND_IN_SET, MySqlParserFLOOR, MySqlParserFORMAT, MySqlParserFOUND_ROWS, MySqlParserFROM_BASE64, MySqlParserFROM_DAYS, MySqlParserFROM_UNIXTIME, MySqlParserGEOMCOLLFROMTEXT, MySqlParserGEOMCOLLFROMWKB, MySqlParserGEOMETRYCOLLECTIONFROMTEXT, MySqlParserGEOMETRYCOLLECTIONFROMWKB, MySqlParserGEOMETRYFROMTEXT, MySqlParserGEOMETRYFROMWKB, MySqlParserGEOMETRYN, MySqlParserGEOMETRYTYPE, MySqlParserGEOMFROMTEXT, MySqlParserGEOMFROMWKB, MySqlParserGET_FORMAT, MySqlParserGET_LOCK, MySqlParserGLENGTH, MySqlParserGREATEST, MySqlParserGTID_SUBSET, MySqlParserGTID_SUBTRACT, MySqlParserHEX, MySqlParserIFNULL, MySqlParserINET6_ATON, MySqlParserINET6_NTOA, MySqlParserINET_ATON, MySqlParserINET_NTOA, MySqlParserINSTR, MySqlParserINTERIORRINGN, MySqlParserINTERSECTS, MySqlParserISCLOSED, MySqlParserISEMPTY, MySqlParserISNULL, MySqlParserISSIMPLE, MySqlParserIS_FREE_LOCK, MySqlParserIS_IPV4, MySqlParserIS_IPV4_COMPAT, MySqlParserIS_IPV4_MAPPED, MySqlParserIS_IPV6, MySqlParserIS_USED_LOCK, MySqlParserLAST_INSERT_ID, MySqlParserLCASE, MySqlParserLEAST, MySqlParserLENGTH, MySqlParserLINEFROMTEXT, MySqlParserLINEFROMWKB, MySqlParserLINESTRINGFROMTEXT, MySqlParserLINESTRINGFROMWKB, MySqlParserLN, MySqlParserLOAD_FILE, MySqlParserLOCATE, MySqlParserLOG, MySqlParserLOG10, MySqlParserLOG2, MySqlParserLOWER, MySqlParserLPAD, MySqlParserLTRIM, MySqlParserMAKEDATE, MySqlParserMAKETIME, MySqlParserMAKE_SET, MySqlParserMASTER_POS_WAIT, MySqlParserMBRCONTAINS, MySqlParserMBRDISJOINT, MySqlParserMBREQUAL, MySqlParserMBRINTERSECTS, MySqlParserMBROVERLAPS, MySqlParserMBRTOUCHES, MySqlParserMBRWITHIN, MySqlParserMD5, MySqlParserMLINEFROMTEXT, MySqlParserMLINEFROMWKB, MySqlParserMONTHNAME, MySqlParserMPOINTFROMTEXT, MySqlParserMPOINTFROMWKB, MySqlParserMPOLYFROMTEXT, MySqlParserMPOLYFROMWKB, MySqlParserMULTILINESTRINGFROMTEXT, MySqlParserMULTILINESTRINGFROMWKB, MySqlParserMULTIPOINTFROMTEXT, MySqlParserMULTIPOINTFROMWKB, MySqlParserMULTIPOLYGONFROMTEXT, MySqlParserMULTIPOLYGONFROMWKB, MySqlParserNAME_CONST, MySqlParserNULLIF, MySqlParserNUMGEOMETRIES, MySqlParserNUMINTERIORRINGS, MySqlParserNUMPOINTS, MySqlParserOCT, MySqlParserOCTET_LENGTH, MySqlParserORD, MySqlParserOVERLAPS, MySqlParserPERIOD_ADD, MySqlParserPERIOD_DIFF, MySqlParserPI, MySqlParserPOINTFROMTEXT, MySqlParserPOINTFROMWKB, MySqlParserPOINTN, MySqlParserPOLYFROMTEXT, MySqlParserPOLYFROMWKB, MySqlParserPOLYGONFROMTEXT, MySqlParserPOLYGONFROMWKB, MySqlParserPOW, MySqlParserPOWER, MySqlParserQUOTE, MySqlParserRADIANS, MySqlParserRAND, MySqlParserRANDOM, MySqlParserRANDOM_BYTES, MySqlParserRELEASE_LOCK, MySqlParserREVERSE, MySqlParserROUND, MySqlParserROW_COUNT, MySqlParserRPAD, MySqlParserRTRIM, MySqlParserSEC_TO_TIME, MySqlParserSESSION_USER, MySqlParserSHA, MySqlParserSHA1, MySqlParserSHA2, MySqlParserSIGN, MySqlParserSIN, MySqlParserSLEEP, MySqlParserSOUNDEX, MySqlParserSQL_THREAD_WAIT_AFTER_GTIDS, MySqlParserSQRT, MySqlParserSRID, MySqlParserSTARTPOINT, MySqlParserSTRCMP, MySqlParserSTR_TO_DATE, MySqlParserST_AREA, MySqlParserST_ASBINARY, MySqlParserST_ASTEXT, MySqlParserST_ASWKB, MySqlParserST_ASWKT, MySqlParserST_BUFFER, MySqlParserST_CENTROID, MySqlParserST_CONTAINS, MySqlParserST_CROSSES, MySqlParserST_DIFFERENCE, MySqlParserST_DIMENSION, MySqlParserST_DISJOINT, MySqlParserST_DISTANCE, MySqlParserST_ENDPOINT, MySqlParserST_ENVELOPE, MySqlParserST_EQUALS, MySqlParserST_EXTERIORRING, MySqlParserST_GEOMCOLLFROMTEXT, MySqlParserST_GEOMCOLLFROMTXT, MySqlParserST_GEOMCOLLFROMWKB, MySqlParserST_GEOMETRYCOLLECTIONFROMTEXT, MySqlParserST_GEOMETRYCOLLECTIONFROMWKB, MySqlParserST_GEOMETRYFROMTEXT, MySqlParserST_GEOMETRYFROMWKB, MySqlParserST_GEOMETRYN, MySqlParserST_GEOMETRYTYPE, MySqlParserST_GEOMFROMTEXT, MySqlParserST_GEOMFROMWKB, MySqlParserST_INTERIORRINGN, MySqlParserST_INTERSECTION, MySqlParserST_INTERSECTS, MySqlParserST_ISCLOSED, MySqlParserST_ISEMPTY, MySqlParserST_ISSIMPLE, MySqlParserST_LINEFROMTEXT, MySqlParserST_LINEFROMWKB, MySqlParserST_LINESTRINGFROMTEXT, MySqlParserST_LINESTRINGFROMWKB, MySqlParserST_NUMGEOMETRIES, MySqlParserST_NUMINTERIORRING, MySqlParserST_NUMINTERIORRINGS, MySqlParserST_NUMPOINTS, MySqlParserST_OVERLAPS, MySqlParserST_POINTFROMTEXT, MySqlParserST_POINTFROMWKB, MySqlParserST_POINTN, MySqlParserST_POLYFROMTEXT, MySqlParserST_POLYFROMWKB, MySqlParserST_POLYGONFROMTEXT, MySqlParserST_POLYGONFROMWKB, MySqlParserST_SRID, MySqlParserST_STARTPOINT, MySqlParserST_SYMDIFFERENCE, MySqlParserST_TOUCHES, MySqlParserST_UNION, MySqlParserST_WITHIN, MySqlParserST_X, MySqlParserST_Y, MySqlParserSTRING_TO_VECTOR, MySqlParserSUBDATE, MySqlParserSUBSTRING_INDEX, MySqlParserSUBTIME, MySqlParserSYSTEM_USER, MySqlParserTAN, MySqlParserTIMEDIFF, MySqlParserTIMESTAMPADD, MySqlParserTIMESTAMPDIFF, MySqlParserTIME_FORMAT, MySqlParserTIME_TO_SEC, MySqlParserTOUCHES, MySqlParserTO_BASE64, MySqlParserTO_DAYS, MySqlParserTO_SECONDS, MySqlParserUCASE, MySqlParserUNCOMPRESS, MySqlParserUNCOMPRESSED_LENGTH, MySqlParserUNHEX, MySqlParserUNIX_TIMESTAMP, MySqlParserUPDATEXML, MySqlParserUPPER, MySqlParserUUID, MySqlParserUUID_SHORT, MySqlParserVALIDATE_PASSWORD_STRENGTH, MySqlParserVECTOR_DIM, MySqlParserVECTOR_TO_STRING, MySqlParserVERSION, MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS, MySqlParserWEEKDAY, MySqlParserWEEKOFYEAR, MySqlParserWEIGHT_STRING, MySqlParserWITHIN, MySqlParserYEARWEEK, MySqlParserY_FUNCTION, MySqlParserX_FUNCTION, MySqlParserMOD: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7195) + p.FunctionNameBase() + } + + case MySqlParserASCII: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7196) + p.Match(MySqlParserASCII) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserCURDATE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(7197) + p.Match(MySqlParserCURDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserCURRENT_DATE: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(7198) + p.Match(MySqlParserCURRENT_DATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserCURRENT_TIME: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(7199) + p.Match(MySqlParserCURRENT_TIME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserCURRENT_TIMESTAMP: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(7200) + p.Match(MySqlParserCURRENT_TIMESTAMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserCURTIME: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(7201) + p.Match(MySqlParserCURTIME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserDATE_ADD: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(7202) + p.Match(MySqlParserDATE_ADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserDATE_SUB: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(7203) + p.Match(MySqlParserDATE_SUB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserIF: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(7204) + p.Match(MySqlParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserINSERT: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(7205) + p.Match(MySqlParserINSERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserLOCALTIME: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(7206) + p.Match(MySqlParserLOCALTIME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserLOCALTIMESTAMP: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(7207) + p.Match(MySqlParserLOCALTIMESTAMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserMID: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(7208) + p.Match(MySqlParserMID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserNOW: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(7209) + p.Match(MySqlParserNOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserREPEAT: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(7210) + p.Match(MySqlParserREPEAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserREPLACE: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(7211) + p.Match(MySqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserSUBSTR: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(7212) + p.Match(MySqlParserSUBSTR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserSUBSTRING: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(7213) + p.Match(MySqlParserSUBSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserSYSDATE: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(7214) + p.Match(MySqlParserSYSDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserTRIM: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(7215) + p.Match(MySqlParserTRIM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserUTC_DATE: + p.EnterOuterAlt(localctx, 22) + { + p.SetState(7216) + p.Match(MySqlParserUTC_DATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserUTC_TIME: + p.EnterOuterAlt(localctx, 23) + { + p.SetState(7217) + p.Match(MySqlParserUTC_TIME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserUTC_TIMESTAMP: + p.EnterOuterAlt(localctx, 24) + { + p.SetState(7218) + p.Match(MySqlParserUTC_TIMESTAMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPasswordFunctionClauseContext is an interface to support dynamic dispatch. +type IPasswordFunctionClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetFunctionName returns the functionName token. + GetFunctionName() antlr.Token + + // SetFunctionName sets the functionName token. + SetFunctionName(antlr.Token) + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + FunctionArg() IFunctionArgContext + RR_BRACKET() antlr.TerminalNode + PASSWORD() antlr.TerminalNode + OLD_PASSWORD() antlr.TerminalNode + + // IsPasswordFunctionClauseContext differentiates from other interfaces. + IsPasswordFunctionClauseContext() +} + +type PasswordFunctionClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + functionName antlr.Token +} + +func NewEmptyPasswordFunctionClauseContext() *PasswordFunctionClauseContext { + var p = new(PasswordFunctionClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_passwordFunctionClause + return p +} + +func InitEmptyPasswordFunctionClauseContext(p *PasswordFunctionClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_passwordFunctionClause +} + +func (*PasswordFunctionClauseContext) IsPasswordFunctionClauseContext() {} + +func NewPasswordFunctionClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PasswordFunctionClauseContext { + var p = new(PasswordFunctionClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_passwordFunctionClause + + return p +} + +func (s *PasswordFunctionClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *PasswordFunctionClauseContext) GetFunctionName() antlr.Token { return s.functionName } + +func (s *PasswordFunctionClauseContext) SetFunctionName(v antlr.Token) { s.functionName = v } + +func (s *PasswordFunctionClauseContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *PasswordFunctionClauseContext) FunctionArg() IFunctionArgContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionArgContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunctionArgContext) +} + +func (s *PasswordFunctionClauseContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *PasswordFunctionClauseContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(MySqlParserPASSWORD, 0) +} + +func (s *PasswordFunctionClauseContext) OLD_PASSWORD() antlr.TerminalNode { + return s.GetToken(MySqlParserOLD_PASSWORD, 0) +} + +func (s *PasswordFunctionClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PasswordFunctionClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PasswordFunctionClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterPasswordFunctionClause(s) + } +} + +func (s *PasswordFunctionClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitPasswordFunctionClause(s) + } +} + +func (p *MySqlParser) PasswordFunctionClause() (localctx IPasswordFunctionClauseContext) { + localctx = NewPasswordFunctionClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 682, MySqlParserRULE_passwordFunctionClause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7221) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*PasswordFunctionClauseContext).functionName = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserOLD_PASSWORD || _la == MySqlParserPASSWORD) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*PasswordFunctionClauseContext).functionName = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(7222) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7223) + p.FunctionArg() + } + { + p.SetState(7224) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunctionArgsContext is an interface to support dynamic dispatch. +type IFunctionArgsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllConstant() []IConstantContext + Constant(i int) IConstantContext + AllFullColumnName() []IFullColumnNameContext + FullColumnName(i int) IFullColumnNameContext + AllFunctionCall() []IFunctionCallContext + FunctionCall(i int) IFunctionCallContext + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsFunctionArgsContext differentiates from other interfaces. + IsFunctionArgsContext() +} + +type FunctionArgsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunctionArgsContext() *FunctionArgsContext { + var p = new(FunctionArgsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_functionArgs + return p +} + +func InitEmptyFunctionArgsContext(p *FunctionArgsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_functionArgs +} + +func (*FunctionArgsContext) IsFunctionArgsContext() {} + +func NewFunctionArgsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionArgsContext { + var p = new(FunctionArgsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_functionArgs + + return p +} + +func (s *FunctionArgsContext) GetParser() antlr.Parser { return s.parser } + +func (s *FunctionArgsContext) AllConstant() []IConstantContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IConstantContext); ok { + len++ + } + } + + tst := make([]IConstantContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IConstantContext); ok { + tst[i] = t.(IConstantContext) + i++ + } + } + + return tst +} + +func (s *FunctionArgsContext) Constant(i int) IConstantContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstantContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IConstantContext) +} + +func (s *FunctionArgsContext) AllFullColumnName() []IFullColumnNameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFullColumnNameContext); ok { + len++ + } + } + + tst := make([]IFullColumnNameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFullColumnNameContext); ok { + tst[i] = t.(IFullColumnNameContext) + i++ + } + } + + return tst +} + +func (s *FunctionArgsContext) FullColumnName(i int) IFullColumnNameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFullColumnNameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFullColumnNameContext) +} + +func (s *FunctionArgsContext) AllFunctionCall() []IFunctionCallContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFunctionCallContext); ok { + len++ + } + } + + tst := make([]IFunctionCallContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFunctionCallContext); ok { + tst[i] = t.(IFunctionCallContext) + i++ + } + } + + return tst +} + +func (s *FunctionArgsContext) FunctionCall(i int) IFunctionCallContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionCallContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFunctionCallContext) +} + +func (s *FunctionArgsContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *FunctionArgsContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *FunctionArgsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *FunctionArgsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *FunctionArgsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FunctionArgsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FunctionArgsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterFunctionArgs(s) + } +} + +func (s *FunctionArgsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitFunctionArgs(s) + } +} + +func (p *MySqlParser) FunctionArgs() (localctx IFunctionArgsContext) { + localctx = NewFunctionArgsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 684, MySqlParserRULE_functionArgs) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(7230) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1071, p.GetParserRuleContext()) { + case 1: + { + p.SetState(7226) + p.Constant() + } + + case 2: + { + p.SetState(7227) + p.FullColumnName() + } + + case 3: + { + p.SetState(7228) + p.FunctionCall() + } + + case 4: + { + p.SetState(7229) + p.expression(0) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(7241) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(7232) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7237) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1072, p.GetParserRuleContext()) { + case 1: + { + p.SetState(7233) + p.Constant() + } + + case 2: + { + p.SetState(7234) + p.FullColumnName() + } + + case 3: + { + p.SetState(7235) + p.FunctionCall() + } + + case 4: + { + p.SetState(7236) + p.expression(0) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(7243) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunctionArgContext is an interface to support dynamic dispatch. +type IFunctionArgContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Constant() IConstantContext + FullColumnName() IFullColumnNameContext + FunctionCall() IFunctionCallContext + Expression() IExpressionContext + + // IsFunctionArgContext differentiates from other interfaces. + IsFunctionArgContext() +} + +type FunctionArgContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunctionArgContext() *FunctionArgContext { + var p = new(FunctionArgContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_functionArg + return p +} + +func InitEmptyFunctionArgContext(p *FunctionArgContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_functionArg +} + +func (*FunctionArgContext) IsFunctionArgContext() {} + +func NewFunctionArgContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionArgContext { + var p = new(FunctionArgContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_functionArg + + return p +} + +func (s *FunctionArgContext) GetParser() antlr.Parser { return s.parser } + +func (s *FunctionArgContext) Constant() IConstantContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstantContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstantContext) +} + +func (s *FunctionArgContext) FullColumnName() IFullColumnNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFullColumnNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFullColumnNameContext) +} + +func (s *FunctionArgContext) FunctionCall() IFunctionCallContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionCallContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunctionCallContext) +} + +func (s *FunctionArgContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *FunctionArgContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FunctionArgContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FunctionArgContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterFunctionArg(s) + } +} + +func (s *FunctionArgContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitFunctionArg(s) + } +} + +func (p *MySqlParser) FunctionArg() (localctx IFunctionArgContext) { + localctx = NewFunctionArgContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 686, MySqlParserRULE_functionArg) + p.SetState(7248) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1074, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7244) + p.Constant() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7245) + p.FullColumnName() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(7246) + p.FunctionCall() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(7247) + p.expression(0) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExpressionContext is an interface to support dynamic dispatch. +type IExpressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsExpressionContext differentiates from other interfaces. + IsExpressionContext() +} + +type ExpressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExpressionContext() *ExpressionContext { + var p = new(ExpressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_expression + return p +} + +func InitEmptyExpressionContext(p *ExpressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_expression +} + +func (*ExpressionContext) IsExpressionContext() {} + +func NewExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionContext { + var p = new(ExpressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_expression + + return p +} + +func (s *ExpressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *ExpressionContext) CopyAll(ctx *ExpressionContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *ExpressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type IsExpressionContext struct { + ExpressionContext + testValue antlr.Token +} + +func NewIsExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IsExpressionContext { + var p = new(IsExpressionContext) + + InitEmptyExpressionContext(&p.ExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*ExpressionContext)) + + return p +} + +func (s *IsExpressionContext) GetTestValue() antlr.Token { return s.testValue } + +func (s *IsExpressionContext) SetTestValue(v antlr.Token) { s.testValue = v } + +func (s *IsExpressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IsExpressionContext) Predicate() IPredicateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPredicateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPredicateContext) +} + +func (s *IsExpressionContext) IS() antlr.TerminalNode { + return s.GetToken(MySqlParserIS, 0) +} + +func (s *IsExpressionContext) TRUE() antlr.TerminalNode { + return s.GetToken(MySqlParserTRUE, 0) +} + +func (s *IsExpressionContext) FALSE() antlr.TerminalNode { + return s.GetToken(MySqlParserFALSE, 0) +} + +func (s *IsExpressionContext) UNKNOWN() antlr.TerminalNode { + return s.GetToken(MySqlParserUNKNOWN, 0) +} + +func (s *IsExpressionContext) NOT() antlr.TerminalNode { + return s.GetToken(MySqlParserNOT, 0) +} + +func (s *IsExpressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterIsExpression(s) + } +} + +func (s *IsExpressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitIsExpression(s) + } +} + +type NotExpressionContext struct { + ExpressionContext + notOperator antlr.Token +} + +func NewNotExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NotExpressionContext { + var p = new(NotExpressionContext) + + InitEmptyExpressionContext(&p.ExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*ExpressionContext)) + + return p +} + +func (s *NotExpressionContext) GetNotOperator() antlr.Token { return s.notOperator } + +func (s *NotExpressionContext) SetNotOperator(v antlr.Token) { s.notOperator = v } + +func (s *NotExpressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *NotExpressionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *NotExpressionContext) NOT() antlr.TerminalNode { + return s.GetToken(MySqlParserNOT, 0) +} + +func (s *NotExpressionContext) EXCLAMATION_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEXCLAMATION_SYMBOL, 0) +} + +func (s *NotExpressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterNotExpression(s) + } +} + +func (s *NotExpressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitNotExpression(s) + } +} + +type LogicalExpressionContext struct { + ExpressionContext +} + +func NewLogicalExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LogicalExpressionContext { + var p = new(LogicalExpressionContext) + + InitEmptyExpressionContext(&p.ExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*ExpressionContext)) + + return p +} + +func (s *LogicalExpressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LogicalExpressionContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *LogicalExpressionContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *LogicalExpressionContext) LogicalOperator() ILogicalOperatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogicalOperatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILogicalOperatorContext) +} + +func (s *LogicalExpressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterLogicalExpression(s) + } +} + +func (s *LogicalExpressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitLogicalExpression(s) + } +} + +type PredicateExpressionContext struct { + ExpressionContext +} + +func NewPredicateExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PredicateExpressionContext { + var p = new(PredicateExpressionContext) + + InitEmptyExpressionContext(&p.ExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*ExpressionContext)) + + return p +} + +func (s *PredicateExpressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PredicateExpressionContext) Predicate() IPredicateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPredicateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPredicateContext) +} + +func (s *PredicateExpressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterPredicateExpression(s) + } +} + +func (s *PredicateExpressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitPredicateExpression(s) + } +} + +func (p *MySqlParser) Expression() (localctx IExpressionContext) { + return p.expression(0) +} + +func (p *MySqlParser) expression(_p int) (localctx IExpressionContext) { + var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() + + _parentState := p.GetState() + localctx = NewExpressionContext(p, p.GetParserRuleContext(), _parentState) + var _prevctx IExpressionContext = localctx + var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. + _startState := 688 + p.EnterRecursionRule(localctx, 688, MySqlParserRULE_expression, _p) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(7261) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1076, p.GetParserRuleContext()) { + case 1: + localctx = NewNotExpressionContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + + { + p.SetState(7251) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*NotExpressionContext).notOperator = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserNOT || _la == MySqlParserEXCLAMATION_SYMBOL) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*NotExpressionContext).notOperator = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(7252) + p.expression(4) + } + + case 2: + localctx = NewIsExpressionContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(7253) + p.predicate(0) + } + { + p.SetState(7254) + p.Match(MySqlParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7256) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserNOT { + { + p.SetState(7255) + p.Match(MySqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7258) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*IsExpressionContext).testValue = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserFALSE || _la == MySqlParserTRUE || _la == MySqlParserUNKNOWN) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*IsExpressionContext).testValue = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 3: + localctx = NewPredicateExpressionContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(7260) + p.predicate(0) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1)) + p.SetState(7269) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1077, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + if p.GetParseListeners() != nil { + p.TriggerExitRuleEvent() + } + _prevctx = localctx + localctx = NewLogicalExpressionContext(p, NewExpressionContext(p, _parentctx, _parentState)) + p.PushNewRecursionContext(localctx, _startState, MySqlParserRULE_expression) + p.SetState(7263) + + if !(p.Precpred(p.GetParserRuleContext(), 3)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 3)", "")) + goto errorExit + } + { + p.SetState(7264) + p.LogicalOperator() + } + { + p.SetState(7265) + p.expression(4) + } + + } + p.SetState(7271) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1077, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.UnrollRecursionContexts(_parentctx) + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPredicateContext is an interface to support dynamic dispatch. +type IPredicateContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsPredicateContext differentiates from other interfaces. + IsPredicateContext() +} + +type PredicateContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPredicateContext() *PredicateContext { + var p = new(PredicateContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_predicate + return p +} + +func InitEmptyPredicateContext(p *PredicateContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_predicate +} + +func (*PredicateContext) IsPredicateContext() {} + +func NewPredicateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PredicateContext { + var p = new(PredicateContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_predicate + + return p +} + +func (s *PredicateContext) GetParser() antlr.Parser { return s.parser } + +func (s *PredicateContext) CopyAll(ctx *PredicateContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *PredicateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PredicateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type SoundsLikePredicateContext struct { + PredicateContext +} + +func NewSoundsLikePredicateContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SoundsLikePredicateContext { + var p = new(SoundsLikePredicateContext) + + InitEmptyPredicateContext(&p.PredicateContext) + p.parser = parser + p.CopyAll(ctx.(*PredicateContext)) + + return p +} + +func (s *SoundsLikePredicateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SoundsLikePredicateContext) AllPredicate() []IPredicateContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPredicateContext); ok { + len++ + } + } + + tst := make([]IPredicateContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPredicateContext); ok { + tst[i] = t.(IPredicateContext) + i++ + } + } + + return tst +} + +func (s *SoundsLikePredicateContext) Predicate(i int) IPredicateContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPredicateContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPredicateContext) +} + +func (s *SoundsLikePredicateContext) SOUNDS() antlr.TerminalNode { + return s.GetToken(MySqlParserSOUNDS, 0) +} + +func (s *SoundsLikePredicateContext) LIKE() antlr.TerminalNode { + return s.GetToken(MySqlParserLIKE, 0) +} + +func (s *SoundsLikePredicateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSoundsLikePredicate(s) + } +} + +func (s *SoundsLikePredicateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSoundsLikePredicate(s) + } +} + +type ExpressionAtomPredicateContext struct { + PredicateContext +} + +func NewExpressionAtomPredicateContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExpressionAtomPredicateContext { + var p = new(ExpressionAtomPredicateContext) + + InitEmptyPredicateContext(&p.PredicateContext) + p.parser = parser + p.CopyAll(ctx.(*PredicateContext)) + + return p +} + +func (s *ExpressionAtomPredicateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ExpressionAtomPredicateContext) ExpressionAtom() IExpressionAtomContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionAtomContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionAtomContext) +} + +func (s *ExpressionAtomPredicateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterExpressionAtomPredicate(s) + } +} + +func (s *ExpressionAtomPredicateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitExpressionAtomPredicate(s) + } +} + +type SubqueryComparisonPredicateContext struct { + PredicateContext + quantifier antlr.Token +} + +func NewSubqueryComparisonPredicateContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SubqueryComparisonPredicateContext { + var p = new(SubqueryComparisonPredicateContext) + + InitEmptyPredicateContext(&p.PredicateContext) + p.parser = parser + p.CopyAll(ctx.(*PredicateContext)) + + return p +} + +func (s *SubqueryComparisonPredicateContext) GetQuantifier() antlr.Token { return s.quantifier } + +func (s *SubqueryComparisonPredicateContext) SetQuantifier(v antlr.Token) { s.quantifier = v } + +func (s *SubqueryComparisonPredicateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SubqueryComparisonPredicateContext) Predicate() IPredicateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPredicateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPredicateContext) +} + +func (s *SubqueryComparisonPredicateContext) ComparisonOperator() IComparisonOperatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComparisonOperatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComparisonOperatorContext) +} + +func (s *SubqueryComparisonPredicateContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *SubqueryComparisonPredicateContext) SelectStatement() ISelectStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelectStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelectStatementContext) +} + +func (s *SubqueryComparisonPredicateContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *SubqueryComparisonPredicateContext) ALL() antlr.TerminalNode { + return s.GetToken(MySqlParserALL, 0) +} + +func (s *SubqueryComparisonPredicateContext) ANY() antlr.TerminalNode { + return s.GetToken(MySqlParserANY, 0) +} + +func (s *SubqueryComparisonPredicateContext) SOME() antlr.TerminalNode { + return s.GetToken(MySqlParserSOME, 0) +} + +func (s *SubqueryComparisonPredicateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSubqueryComparisonPredicate(s) + } +} + +func (s *SubqueryComparisonPredicateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSubqueryComparisonPredicate(s) + } +} + +type JsonMemberOfPredicateContext struct { + PredicateContext +} + +func NewJsonMemberOfPredicateContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *JsonMemberOfPredicateContext { + var p = new(JsonMemberOfPredicateContext) + + InitEmptyPredicateContext(&p.PredicateContext) + p.parser = parser + p.CopyAll(ctx.(*PredicateContext)) + + return p +} + +func (s *JsonMemberOfPredicateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *JsonMemberOfPredicateContext) AllPredicate() []IPredicateContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPredicateContext); ok { + len++ + } + } + + tst := make([]IPredicateContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPredicateContext); ok { + tst[i] = t.(IPredicateContext) + i++ + } + } + + return tst +} + +func (s *JsonMemberOfPredicateContext) Predicate(i int) IPredicateContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPredicateContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPredicateContext) +} + +func (s *JsonMemberOfPredicateContext) MEMBER() antlr.TerminalNode { + return s.GetToken(MySqlParserMEMBER, 0) +} + +func (s *JsonMemberOfPredicateContext) OF() antlr.TerminalNode { + return s.GetToken(MySqlParserOF, 0) +} + +func (s *JsonMemberOfPredicateContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *JsonMemberOfPredicateContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *JsonMemberOfPredicateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterJsonMemberOfPredicate(s) + } +} + +func (s *JsonMemberOfPredicateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitJsonMemberOfPredicate(s) + } +} + +type BinaryComparisonPredicateContext struct { + PredicateContext + left IPredicateContext + right IPredicateContext +} + +func NewBinaryComparisonPredicateContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BinaryComparisonPredicateContext { + var p = new(BinaryComparisonPredicateContext) + + InitEmptyPredicateContext(&p.PredicateContext) + p.parser = parser + p.CopyAll(ctx.(*PredicateContext)) + + return p +} + +func (s *BinaryComparisonPredicateContext) GetLeft() IPredicateContext { return s.left } + +func (s *BinaryComparisonPredicateContext) GetRight() IPredicateContext { return s.right } + +func (s *BinaryComparisonPredicateContext) SetLeft(v IPredicateContext) { s.left = v } + +func (s *BinaryComparisonPredicateContext) SetRight(v IPredicateContext) { s.right = v } + +func (s *BinaryComparisonPredicateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *BinaryComparisonPredicateContext) ComparisonOperator() IComparisonOperatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComparisonOperatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComparisonOperatorContext) +} + +func (s *BinaryComparisonPredicateContext) AllPredicate() []IPredicateContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPredicateContext); ok { + len++ + } + } + + tst := make([]IPredicateContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPredicateContext); ok { + tst[i] = t.(IPredicateContext) + i++ + } + } + + return tst +} + +func (s *BinaryComparisonPredicateContext) Predicate(i int) IPredicateContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPredicateContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPredicateContext) +} + +func (s *BinaryComparisonPredicateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterBinaryComparisonPredicate(s) + } +} + +func (s *BinaryComparisonPredicateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitBinaryComparisonPredicate(s) + } +} + +type InPredicateContext struct { + PredicateContext +} + +func NewInPredicateContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *InPredicateContext { + var p = new(InPredicateContext) + + InitEmptyPredicateContext(&p.PredicateContext) + p.parser = parser + p.CopyAll(ctx.(*PredicateContext)) + + return p +} + +func (s *InPredicateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *InPredicateContext) Predicate() IPredicateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPredicateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPredicateContext) +} + +func (s *InPredicateContext) IN() antlr.TerminalNode { + return s.GetToken(MySqlParserIN, 0) +} + +func (s *InPredicateContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *InPredicateContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *InPredicateContext) SelectStatement() ISelectStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelectStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelectStatementContext) +} + +func (s *InPredicateContext) Expressions() IExpressionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionsContext) +} + +func (s *InPredicateContext) NOT() antlr.TerminalNode { + return s.GetToken(MySqlParserNOT, 0) +} + +func (s *InPredicateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterInPredicate(s) + } +} + +func (s *InPredicateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitInPredicate(s) + } +} + +type BetweenPredicateContext struct { + PredicateContext +} + +func NewBetweenPredicateContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BetweenPredicateContext { + var p = new(BetweenPredicateContext) + + InitEmptyPredicateContext(&p.PredicateContext) + p.parser = parser + p.CopyAll(ctx.(*PredicateContext)) + + return p +} + +func (s *BetweenPredicateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *BetweenPredicateContext) AllPredicate() []IPredicateContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPredicateContext); ok { + len++ + } + } + + tst := make([]IPredicateContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPredicateContext); ok { + tst[i] = t.(IPredicateContext) + i++ + } + } + + return tst +} + +func (s *BetweenPredicateContext) Predicate(i int) IPredicateContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPredicateContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPredicateContext) +} + +func (s *BetweenPredicateContext) BETWEEN() antlr.TerminalNode { + return s.GetToken(MySqlParserBETWEEN, 0) +} + +func (s *BetweenPredicateContext) AND() antlr.TerminalNode { + return s.GetToken(MySqlParserAND, 0) +} + +func (s *BetweenPredicateContext) NOT() antlr.TerminalNode { + return s.GetToken(MySqlParserNOT, 0) +} + +func (s *BetweenPredicateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterBetweenPredicate(s) + } +} + +func (s *BetweenPredicateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitBetweenPredicate(s) + } +} + +type IsNullPredicateContext struct { + PredicateContext +} + +func NewIsNullPredicateContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IsNullPredicateContext { + var p = new(IsNullPredicateContext) + + InitEmptyPredicateContext(&p.PredicateContext) + p.parser = parser + p.CopyAll(ctx.(*PredicateContext)) + + return p +} + +func (s *IsNullPredicateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IsNullPredicateContext) Predicate() IPredicateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPredicateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPredicateContext) +} + +func (s *IsNullPredicateContext) IS() antlr.TerminalNode { + return s.GetToken(MySqlParserIS, 0) +} + +func (s *IsNullPredicateContext) NullNotnull() INullNotnullContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INullNotnullContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INullNotnullContext) +} + +func (s *IsNullPredicateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterIsNullPredicate(s) + } +} + +func (s *IsNullPredicateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitIsNullPredicate(s) + } +} + +type LikePredicateContext struct { + PredicateContext +} + +func NewLikePredicateContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LikePredicateContext { + var p = new(LikePredicateContext) + + InitEmptyPredicateContext(&p.PredicateContext) + p.parser = parser + p.CopyAll(ctx.(*PredicateContext)) + + return p +} + +func (s *LikePredicateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LikePredicateContext) AllPredicate() []IPredicateContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPredicateContext); ok { + len++ + } + } + + tst := make([]IPredicateContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPredicateContext); ok { + tst[i] = t.(IPredicateContext) + i++ + } + } + + return tst +} + +func (s *LikePredicateContext) Predicate(i int) IPredicateContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPredicateContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPredicateContext) +} + +func (s *LikePredicateContext) LIKE() antlr.TerminalNode { + return s.GetToken(MySqlParserLIKE, 0) +} + +func (s *LikePredicateContext) NOT() antlr.TerminalNode { + return s.GetToken(MySqlParserNOT, 0) +} + +func (s *LikePredicateContext) ESCAPE() antlr.TerminalNode { + return s.GetToken(MySqlParserESCAPE, 0) +} + +func (s *LikePredicateContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_LITERAL, 0) +} + +func (s *LikePredicateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterLikePredicate(s) + } +} + +func (s *LikePredicateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitLikePredicate(s) + } +} + +type RegexpPredicateContext struct { + PredicateContext + regex antlr.Token +} + +func NewRegexpPredicateContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RegexpPredicateContext { + var p = new(RegexpPredicateContext) + + InitEmptyPredicateContext(&p.PredicateContext) + p.parser = parser + p.CopyAll(ctx.(*PredicateContext)) + + return p +} + +func (s *RegexpPredicateContext) GetRegex() antlr.Token { return s.regex } + +func (s *RegexpPredicateContext) SetRegex(v antlr.Token) { s.regex = v } + +func (s *RegexpPredicateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RegexpPredicateContext) AllPredicate() []IPredicateContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPredicateContext); ok { + len++ + } + } + + tst := make([]IPredicateContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPredicateContext); ok { + tst[i] = t.(IPredicateContext) + i++ + } + } + + return tst +} + +func (s *RegexpPredicateContext) Predicate(i int) IPredicateContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPredicateContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPredicateContext) +} + +func (s *RegexpPredicateContext) REGEXP() antlr.TerminalNode { + return s.GetToken(MySqlParserREGEXP, 0) +} + +func (s *RegexpPredicateContext) RLIKE() antlr.TerminalNode { + return s.GetToken(MySqlParserRLIKE, 0) +} + +func (s *RegexpPredicateContext) NOT() antlr.TerminalNode { + return s.GetToken(MySqlParserNOT, 0) +} + +func (s *RegexpPredicateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterRegexpPredicate(s) + } +} + +func (s *RegexpPredicateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitRegexpPredicate(s) + } +} + +func (p *MySqlParser) Predicate() (localctx IPredicateContext) { + return p.predicate(0) +} + +func (p *MySqlParser) predicate(_p int) (localctx IPredicateContext) { + var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() + + _parentState := p.GetState() + localctx = NewPredicateContext(p, p.GetParserRuleContext(), _parentState) + var _prevctx IPredicateContext = localctx + var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. + _startState := 690 + p.EnterRecursionRule(localctx, 690, MySqlParserRULE_predicate, _p) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + localctx = NewExpressionAtomPredicateContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + + { + p.SetState(7273) + p.expressionAtom(0) + } + + p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1)) + p.SetState(7339) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1085, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + if p.GetParseListeners() != nil { + p.TriggerExitRuleEvent() + } + _prevctx = localctx + p.SetState(7337) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1084, p.GetParserRuleContext()) { + case 1: + localctx = NewBinaryComparisonPredicateContext(p, NewPredicateContext(p, _parentctx, _parentState)) + localctx.(*BinaryComparisonPredicateContext).left = _prevctx + + p.PushNewRecursionContext(localctx, _startState, MySqlParserRULE_predicate) + p.SetState(7275) + + if !(p.Precpred(p.GetParserRuleContext(), 8)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 8)", "")) + goto errorExit + } + { + p.SetState(7276) + p.ComparisonOperator() + } + { + p.SetState(7277) + + var _x = p.predicate(9) + + localctx.(*BinaryComparisonPredicateContext).right = _x + } + + case 2: + localctx = NewBetweenPredicateContext(p, NewPredicateContext(p, _parentctx, _parentState)) + p.PushNewRecursionContext(localctx, _startState, MySqlParserRULE_predicate) + p.SetState(7279) + + if !(p.Precpred(p.GetParserRuleContext(), 6)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 6)", "")) + goto errorExit + } + p.SetState(7281) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserNOT { + { + p.SetState(7280) + p.Match(MySqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7283) + p.Match(MySqlParserBETWEEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7284) + p.predicate(0) + } + { + p.SetState(7285) + p.Match(MySqlParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7286) + p.predicate(7) + } + + case 3: + localctx = NewSoundsLikePredicateContext(p, NewPredicateContext(p, _parentctx, _parentState)) + p.PushNewRecursionContext(localctx, _startState, MySqlParserRULE_predicate) + p.SetState(7288) + + if !(p.Precpred(p.GetParserRuleContext(), 5)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 5)", "")) + goto errorExit + } + { + p.SetState(7289) + p.Match(MySqlParserSOUNDS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7290) + p.Match(MySqlParserLIKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7291) + p.predicate(6) + } + + case 4: + localctx = NewRegexpPredicateContext(p, NewPredicateContext(p, _parentctx, _parentState)) + p.PushNewRecursionContext(localctx, _startState, MySqlParserRULE_predicate) + p.SetState(7292) + + if !(p.Precpred(p.GetParserRuleContext(), 3)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 3)", "")) + goto errorExit + } + p.SetState(7294) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserNOT { + { + p.SetState(7293) + p.Match(MySqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7296) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*RegexpPredicateContext).regex = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserREGEXP || _la == MySqlParserRLIKE) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*RegexpPredicateContext).regex = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(7297) + p.predicate(4) + } + + case 5: + localctx = NewInPredicateContext(p, NewPredicateContext(p, _parentctx, _parentState)) + p.PushNewRecursionContext(localctx, _startState, MySqlParserRULE_predicate) + p.SetState(7298) + + if !(p.Precpred(p.GetParserRuleContext(), 10)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 10)", "")) + goto errorExit + } + p.SetState(7300) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserNOT { + { + p.SetState(7299) + p.Match(MySqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7302) + p.Match(MySqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7303) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7306) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1081, p.GetParserRuleContext()) { + case 1: + { + p.SetState(7304) + p.SelectStatement() + } + + case 2: + { + p.SetState(7305) + p.Expressions() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(7308) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + localctx = NewIsNullPredicateContext(p, NewPredicateContext(p, _parentctx, _parentState)) + p.PushNewRecursionContext(localctx, _startState, MySqlParserRULE_predicate) + p.SetState(7310) + + if !(p.Precpred(p.GetParserRuleContext(), 9)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 9)", "")) + goto errorExit + } + { + p.SetState(7311) + p.Match(MySqlParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7312) + p.NullNotnull() + } + + case 7: + localctx = NewSubqueryComparisonPredicateContext(p, NewPredicateContext(p, _parentctx, _parentState)) + p.PushNewRecursionContext(localctx, _startState, MySqlParserRULE_predicate) + p.SetState(7313) + + if !(p.Precpred(p.GetParserRuleContext(), 7)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 7)", "")) + goto errorExit + } + { + p.SetState(7314) + p.ComparisonOperator() + } + { + p.SetState(7315) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*SubqueryComparisonPredicateContext).quantifier = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserALL || _la == MySqlParserANY || _la == MySqlParserSOME) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*SubqueryComparisonPredicateContext).quantifier = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(7316) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7317) + p.SelectStatement() + } + { + p.SetState(7318) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + localctx = NewLikePredicateContext(p, NewPredicateContext(p, _parentctx, _parentState)) + p.PushNewRecursionContext(localctx, _startState, MySqlParserRULE_predicate) + p.SetState(7320) + + if !(p.Precpred(p.GetParserRuleContext(), 4)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 4)", "")) + goto errorExit + } + p.SetState(7322) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MySqlParserNOT { + { + p.SetState(7321) + p.Match(MySqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7324) + p.Match(MySqlParserLIKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7325) + p.predicate(0) + } + p.SetState(7328) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1083, p.GetParserRuleContext()) == 1 { + { + p.SetState(7326) + p.Match(MySqlParserESCAPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7327) + p.Match(MySqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 9: + localctx = NewJsonMemberOfPredicateContext(p, NewPredicateContext(p, _parentctx, _parentState)) + p.PushNewRecursionContext(localctx, _startState, MySqlParserRULE_predicate) + p.SetState(7330) + + if !(p.Precpred(p.GetParserRuleContext(), 2)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 2)", "")) + goto errorExit + } + { + p.SetState(7331) + p.Match(MySqlParserMEMBER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7332) + p.Match(MySqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7333) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7334) + p.predicate(0) + } + { + p.SetState(7335) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + p.SetState(7341) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1085, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.UnrollRecursionContexts(_parentctx) + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExpressionAtomContext is an interface to support dynamic dispatch. +type IExpressionAtomContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsExpressionAtomContext differentiates from other interfaces. + IsExpressionAtomContext() +} + +type ExpressionAtomContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExpressionAtomContext() *ExpressionAtomContext { + var p = new(ExpressionAtomContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_expressionAtom + return p +} + +func InitEmptyExpressionAtomContext(p *ExpressionAtomContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_expressionAtom +} + +func (*ExpressionAtomContext) IsExpressionAtomContext() {} + +func NewExpressionAtomContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionAtomContext { + var p = new(ExpressionAtomContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_expressionAtom + + return p +} + +func (s *ExpressionAtomContext) GetParser() antlr.Parser { return s.parser } + +func (s *ExpressionAtomContext) CopyAll(ctx *ExpressionAtomContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *ExpressionAtomContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ExpressionAtomContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type UnaryExpressionAtomContext struct { + ExpressionAtomContext +} + +func NewUnaryExpressionAtomContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *UnaryExpressionAtomContext { + var p = new(UnaryExpressionAtomContext) + + InitEmptyExpressionAtomContext(&p.ExpressionAtomContext) + p.parser = parser + p.CopyAll(ctx.(*ExpressionAtomContext)) + + return p +} + +func (s *UnaryExpressionAtomContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UnaryExpressionAtomContext) UnaryOperator() IUnaryOperatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnaryOperatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnaryOperatorContext) +} + +func (s *UnaryExpressionAtomContext) ExpressionAtom() IExpressionAtomContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionAtomContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionAtomContext) +} + +func (s *UnaryExpressionAtomContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterUnaryExpressionAtom(s) + } +} + +func (s *UnaryExpressionAtomContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitUnaryExpressionAtom(s) + } +} + +type CollateExpressionAtomContext struct { + ExpressionAtomContext +} + +func NewCollateExpressionAtomContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CollateExpressionAtomContext { + var p = new(CollateExpressionAtomContext) + + InitEmptyExpressionAtomContext(&p.ExpressionAtomContext) + p.parser = parser + p.CopyAll(ctx.(*ExpressionAtomContext)) + + return p +} + +func (s *CollateExpressionAtomContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CollateExpressionAtomContext) ExpressionAtom() IExpressionAtomContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionAtomContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionAtomContext) +} + +func (s *CollateExpressionAtomContext) COLLATE() antlr.TerminalNode { + return s.GetToken(MySqlParserCOLLATE, 0) +} + +func (s *CollateExpressionAtomContext) CollationName() ICollationNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICollationNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICollationNameContext) +} + +func (s *CollateExpressionAtomContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCollateExpressionAtom(s) + } +} + +func (s *CollateExpressionAtomContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCollateExpressionAtom(s) + } +} + +type VariableAssignExpressionAtomContext struct { + ExpressionAtomContext +} + +func NewVariableAssignExpressionAtomContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *VariableAssignExpressionAtomContext { + var p = new(VariableAssignExpressionAtomContext) + + InitEmptyExpressionAtomContext(&p.ExpressionAtomContext) + p.parser = parser + p.CopyAll(ctx.(*ExpressionAtomContext)) + + return p +} + +func (s *VariableAssignExpressionAtomContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *VariableAssignExpressionAtomContext) LOCAL_ID() antlr.TerminalNode { + return s.GetToken(MySqlParserLOCAL_ID, 0) +} + +func (s *VariableAssignExpressionAtomContext) VAR_ASSIGN() antlr.TerminalNode { + return s.GetToken(MySqlParserVAR_ASSIGN, 0) +} + +func (s *VariableAssignExpressionAtomContext) ExpressionAtom() IExpressionAtomContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionAtomContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionAtomContext) +} + +func (s *VariableAssignExpressionAtomContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterVariableAssignExpressionAtom(s) + } +} + +func (s *VariableAssignExpressionAtomContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitVariableAssignExpressionAtom(s) + } +} + +type MysqlVariableExpressionAtomContext struct { + ExpressionAtomContext +} + +func NewMysqlVariableExpressionAtomContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MysqlVariableExpressionAtomContext { + var p = new(MysqlVariableExpressionAtomContext) + + InitEmptyExpressionAtomContext(&p.ExpressionAtomContext) + p.parser = parser + p.CopyAll(ctx.(*ExpressionAtomContext)) + + return p +} + +func (s *MysqlVariableExpressionAtomContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MysqlVariableExpressionAtomContext) MysqlVariable() IMysqlVariableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMysqlVariableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMysqlVariableContext) +} + +func (s *MysqlVariableExpressionAtomContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterMysqlVariableExpressionAtom(s) + } +} + +func (s *MysqlVariableExpressionAtomContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitMysqlVariableExpressionAtom(s) + } +} + +type NestedExpressionAtomContext struct { + ExpressionAtomContext +} + +func NewNestedExpressionAtomContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NestedExpressionAtomContext { + var p = new(NestedExpressionAtomContext) + + InitEmptyExpressionAtomContext(&p.ExpressionAtomContext) + p.parser = parser + p.CopyAll(ctx.(*ExpressionAtomContext)) + + return p +} + +func (s *NestedExpressionAtomContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *NestedExpressionAtomContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *NestedExpressionAtomContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *NestedExpressionAtomContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *NestedExpressionAtomContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *NestedExpressionAtomContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *NestedExpressionAtomContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *NestedExpressionAtomContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterNestedExpressionAtom(s) + } +} + +func (s *NestedExpressionAtomContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitNestedExpressionAtom(s) + } +} + +type NestedRowExpressionAtomContext struct { + ExpressionAtomContext +} + +func NewNestedRowExpressionAtomContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NestedRowExpressionAtomContext { + var p = new(NestedRowExpressionAtomContext) + + InitEmptyExpressionAtomContext(&p.ExpressionAtomContext) + p.parser = parser + p.CopyAll(ctx.(*ExpressionAtomContext)) + + return p +} + +func (s *NestedRowExpressionAtomContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *NestedRowExpressionAtomContext) ROW() antlr.TerminalNode { + return s.GetToken(MySqlParserROW, 0) +} + +func (s *NestedRowExpressionAtomContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *NestedRowExpressionAtomContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *NestedRowExpressionAtomContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *NestedRowExpressionAtomContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *NestedRowExpressionAtomContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MySqlParserCOMMA) +} + +func (s *NestedRowExpressionAtomContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMA, i) +} + +func (s *NestedRowExpressionAtomContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterNestedRowExpressionAtom(s) + } +} + +func (s *NestedRowExpressionAtomContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitNestedRowExpressionAtom(s) + } +} + +type MathExpressionAtomContext struct { + ExpressionAtomContext + left IExpressionAtomContext + right IExpressionAtomContext +} + +func NewMathExpressionAtomContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MathExpressionAtomContext { + var p = new(MathExpressionAtomContext) + + InitEmptyExpressionAtomContext(&p.ExpressionAtomContext) + p.parser = parser + p.CopyAll(ctx.(*ExpressionAtomContext)) + + return p +} + +func (s *MathExpressionAtomContext) GetLeft() IExpressionAtomContext { return s.left } + +func (s *MathExpressionAtomContext) GetRight() IExpressionAtomContext { return s.right } + +func (s *MathExpressionAtomContext) SetLeft(v IExpressionAtomContext) { s.left = v } + +func (s *MathExpressionAtomContext) SetRight(v IExpressionAtomContext) { s.right = v } + +func (s *MathExpressionAtomContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MathExpressionAtomContext) MultOperator() IMultOperatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultOperatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultOperatorContext) +} + +func (s *MathExpressionAtomContext) AllExpressionAtom() []IExpressionAtomContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionAtomContext); ok { + len++ + } + } + + tst := make([]IExpressionAtomContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionAtomContext); ok { + tst[i] = t.(IExpressionAtomContext) + i++ + } + } + + return tst +} + +func (s *MathExpressionAtomContext) ExpressionAtom(i int) IExpressionAtomContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionAtomContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionAtomContext) +} + +func (s *MathExpressionAtomContext) AddOperator() IAddOperatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAddOperatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAddOperatorContext) +} + +func (s *MathExpressionAtomContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterMathExpressionAtom(s) + } +} + +func (s *MathExpressionAtomContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitMathExpressionAtom(s) + } +} + +type ExistsExpressionAtomContext struct { + ExpressionAtomContext +} + +func NewExistsExpressionAtomContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExistsExpressionAtomContext { + var p = new(ExistsExpressionAtomContext) + + InitEmptyExpressionAtomContext(&p.ExpressionAtomContext) + p.parser = parser + p.CopyAll(ctx.(*ExpressionAtomContext)) + + return p +} + +func (s *ExistsExpressionAtomContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ExistsExpressionAtomContext) EXISTS() antlr.TerminalNode { + return s.GetToken(MySqlParserEXISTS, 0) +} + +func (s *ExistsExpressionAtomContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *ExistsExpressionAtomContext) SelectStatement() ISelectStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelectStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelectStatementContext) +} + +func (s *ExistsExpressionAtomContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *ExistsExpressionAtomContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterExistsExpressionAtom(s) + } +} + +func (s *ExistsExpressionAtomContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitExistsExpressionAtom(s) + } +} + +type IntervalExpressionAtomContext struct { + ExpressionAtomContext +} + +func NewIntervalExpressionAtomContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IntervalExpressionAtomContext { + var p = new(IntervalExpressionAtomContext) + + InitEmptyExpressionAtomContext(&p.ExpressionAtomContext) + p.parser = parser + p.CopyAll(ctx.(*ExpressionAtomContext)) + + return p +} + +func (s *IntervalExpressionAtomContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IntervalExpressionAtomContext) INTERVAL() antlr.TerminalNode { + return s.GetToken(MySqlParserINTERVAL, 0) +} + +func (s *IntervalExpressionAtomContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *IntervalExpressionAtomContext) IntervalType() IIntervalTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIntervalTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIntervalTypeContext) +} + +func (s *IntervalExpressionAtomContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterIntervalExpressionAtom(s) + } +} + +func (s *IntervalExpressionAtomContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitIntervalExpressionAtom(s) + } +} + +type JsonExpressionAtomContext struct { + ExpressionAtomContext + left IExpressionAtomContext + right IExpressionAtomContext +} + +func NewJsonExpressionAtomContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *JsonExpressionAtomContext { + var p = new(JsonExpressionAtomContext) + + InitEmptyExpressionAtomContext(&p.ExpressionAtomContext) + p.parser = parser + p.CopyAll(ctx.(*ExpressionAtomContext)) + + return p +} + +func (s *JsonExpressionAtomContext) GetLeft() IExpressionAtomContext { return s.left } + +func (s *JsonExpressionAtomContext) GetRight() IExpressionAtomContext { return s.right } + +func (s *JsonExpressionAtomContext) SetLeft(v IExpressionAtomContext) { s.left = v } + +func (s *JsonExpressionAtomContext) SetRight(v IExpressionAtomContext) { s.right = v } + +func (s *JsonExpressionAtomContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *JsonExpressionAtomContext) JsonOperator() IJsonOperatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJsonOperatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJsonOperatorContext) +} + +func (s *JsonExpressionAtomContext) AllExpressionAtom() []IExpressionAtomContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionAtomContext); ok { + len++ + } + } + + tst := make([]IExpressionAtomContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionAtomContext); ok { + tst[i] = t.(IExpressionAtomContext) + i++ + } + } + + return tst +} + +func (s *JsonExpressionAtomContext) ExpressionAtom(i int) IExpressionAtomContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionAtomContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionAtomContext) +} + +func (s *JsonExpressionAtomContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterJsonExpressionAtom(s) + } +} + +func (s *JsonExpressionAtomContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitJsonExpressionAtom(s) + } +} + +type SubqueryExpressionAtomContext struct { + ExpressionAtomContext +} + +func NewSubqueryExpressionAtomContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SubqueryExpressionAtomContext { + var p = new(SubqueryExpressionAtomContext) + + InitEmptyExpressionAtomContext(&p.ExpressionAtomContext) + p.parser = parser + p.CopyAll(ctx.(*ExpressionAtomContext)) + + return p +} + +func (s *SubqueryExpressionAtomContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SubqueryExpressionAtomContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserLR_BRACKET, 0) +} + +func (s *SubqueryExpressionAtomContext) SelectStatement() ISelectStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelectStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelectStatementContext) +} + +func (s *SubqueryExpressionAtomContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(MySqlParserRR_BRACKET, 0) +} + +func (s *SubqueryExpressionAtomContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterSubqueryExpressionAtom(s) + } +} + +func (s *SubqueryExpressionAtomContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitSubqueryExpressionAtom(s) + } +} + +type ConstantExpressionAtomContext struct { + ExpressionAtomContext +} + +func NewConstantExpressionAtomContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ConstantExpressionAtomContext { + var p = new(ConstantExpressionAtomContext) + + InitEmptyExpressionAtomContext(&p.ExpressionAtomContext) + p.parser = parser + p.CopyAll(ctx.(*ExpressionAtomContext)) + + return p +} + +func (s *ConstantExpressionAtomContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ConstantExpressionAtomContext) Constant() IConstantContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstantContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstantContext) +} + +func (s *ConstantExpressionAtomContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterConstantExpressionAtom(s) + } +} + +func (s *ConstantExpressionAtomContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitConstantExpressionAtom(s) + } +} + +type FunctionCallExpressionAtomContext struct { + ExpressionAtomContext +} + +func NewFunctionCallExpressionAtomContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *FunctionCallExpressionAtomContext { + var p = new(FunctionCallExpressionAtomContext) + + InitEmptyExpressionAtomContext(&p.ExpressionAtomContext) + p.parser = parser + p.CopyAll(ctx.(*ExpressionAtomContext)) + + return p +} + +func (s *FunctionCallExpressionAtomContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FunctionCallExpressionAtomContext) FunctionCall() IFunctionCallContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionCallContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunctionCallContext) +} + +func (s *FunctionCallExpressionAtomContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterFunctionCallExpressionAtom(s) + } +} + +func (s *FunctionCallExpressionAtomContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitFunctionCallExpressionAtom(s) + } +} + +type BinaryExpressionAtomContext struct { + ExpressionAtomContext +} + +func NewBinaryExpressionAtomContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BinaryExpressionAtomContext { + var p = new(BinaryExpressionAtomContext) + + InitEmptyExpressionAtomContext(&p.ExpressionAtomContext) + p.parser = parser + p.CopyAll(ctx.(*ExpressionAtomContext)) + + return p +} + +func (s *BinaryExpressionAtomContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *BinaryExpressionAtomContext) BINARY() antlr.TerminalNode { + return s.GetToken(MySqlParserBINARY, 0) +} + +func (s *BinaryExpressionAtomContext) ExpressionAtom() IExpressionAtomContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionAtomContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionAtomContext) +} + +func (s *BinaryExpressionAtomContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterBinaryExpressionAtom(s) + } +} + +func (s *BinaryExpressionAtomContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitBinaryExpressionAtom(s) + } +} + +type FullColumnNameExpressionAtomContext struct { + ExpressionAtomContext +} + +func NewFullColumnNameExpressionAtomContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *FullColumnNameExpressionAtomContext { + var p = new(FullColumnNameExpressionAtomContext) + + InitEmptyExpressionAtomContext(&p.ExpressionAtomContext) + p.parser = parser + p.CopyAll(ctx.(*ExpressionAtomContext)) + + return p +} + +func (s *FullColumnNameExpressionAtomContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FullColumnNameExpressionAtomContext) FullColumnName() IFullColumnNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFullColumnNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFullColumnNameContext) +} + +func (s *FullColumnNameExpressionAtomContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterFullColumnNameExpressionAtom(s) + } +} + +func (s *FullColumnNameExpressionAtomContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitFullColumnNameExpressionAtom(s) + } +} + +type BitExpressionAtomContext struct { + ExpressionAtomContext + left IExpressionAtomContext + right IExpressionAtomContext +} + +func NewBitExpressionAtomContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BitExpressionAtomContext { + var p = new(BitExpressionAtomContext) + + InitEmptyExpressionAtomContext(&p.ExpressionAtomContext) + p.parser = parser + p.CopyAll(ctx.(*ExpressionAtomContext)) + + return p +} + +func (s *BitExpressionAtomContext) GetLeft() IExpressionAtomContext { return s.left } + +func (s *BitExpressionAtomContext) GetRight() IExpressionAtomContext { return s.right } + +func (s *BitExpressionAtomContext) SetLeft(v IExpressionAtomContext) { s.left = v } + +func (s *BitExpressionAtomContext) SetRight(v IExpressionAtomContext) { s.right = v } + +func (s *BitExpressionAtomContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *BitExpressionAtomContext) BitOperator() IBitOperatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBitOperatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBitOperatorContext) +} + +func (s *BitExpressionAtomContext) AllExpressionAtom() []IExpressionAtomContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionAtomContext); ok { + len++ + } + } + + tst := make([]IExpressionAtomContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionAtomContext); ok { + tst[i] = t.(IExpressionAtomContext) + i++ + } + } + + return tst +} + +func (s *BitExpressionAtomContext) ExpressionAtom(i int) IExpressionAtomContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionAtomContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionAtomContext) +} + +func (s *BitExpressionAtomContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterBitExpressionAtom(s) + } +} + +func (s *BitExpressionAtomContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitBitExpressionAtom(s) + } +} + +func (p *MySqlParser) ExpressionAtom() (localctx IExpressionAtomContext) { + return p.expressionAtom(0) +} + +func (p *MySqlParser) expressionAtom(_p int) (localctx IExpressionAtomContext) { + var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() + + _parentState := p.GetState() + localctx = NewExpressionAtomContext(p, p.GetParserRuleContext(), _parentState) + var _prevctx IExpressionAtomContext = localctx + var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. + _startState := 692 + p.EnterRecursionRule(localctx, 692, MySqlParserRULE_expressionAtom, _p) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(7390) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1088, p.GetParserRuleContext()) { + case 1: + localctx = NewConstantExpressionAtomContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + + { + p.SetState(7343) + p.Constant() + } + + case 2: + localctx = NewFullColumnNameExpressionAtomContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(7344) + p.FullColumnName() + } + + case 3: + localctx = NewFunctionCallExpressionAtomContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(7345) + p.FunctionCall() + } + + case 4: + localctx = NewMysqlVariableExpressionAtomContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(7346) + p.MysqlVariable() + } + + case 5: + localctx = NewUnaryExpressionAtomContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(7347) + p.UnaryOperator() + } + { + p.SetState(7348) + p.expressionAtom(12) + } + + case 6: + localctx = NewBinaryExpressionAtomContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(7350) + p.Match(MySqlParserBINARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7351) + p.expressionAtom(11) + } + + case 7: + localctx = NewVariableAssignExpressionAtomContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(7352) + p.Match(MySqlParserLOCAL_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7353) + p.Match(MySqlParserVAR_ASSIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7354) + p.expressionAtom(10) + } + + case 8: + localctx = NewNestedExpressionAtomContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(7355) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7356) + p.expression(0) + } + p.SetState(7361) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MySqlParserCOMMA { + { + p.SetState(7357) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7358) + p.expression(0) + } + + p.SetState(7363) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(7364) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 9: + localctx = NewNestedRowExpressionAtomContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(7366) + p.Match(MySqlParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7367) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7368) + p.expression(0) + } + p.SetState(7371) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == MySqlParserCOMMA { + { + p.SetState(7369) + p.Match(MySqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7370) + p.expression(0) + } + + p.SetState(7373) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(7375) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 10: + localctx = NewExistsExpressionAtomContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(7377) + p.Match(MySqlParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7378) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7379) + p.SelectStatement() + } + { + p.SetState(7380) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 11: + localctx = NewSubqueryExpressionAtomContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(7382) + p.Match(MySqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7383) + p.SelectStatement() + } + { + p.SetState(7384) + p.Match(MySqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 12: + localctx = NewIntervalExpressionAtomContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(7386) + p.Match(MySqlParserINTERVAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7387) + p.expression(0) + } + { + p.SetState(7388) + p.IntervalType() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1)) + p.SetState(7413) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1090, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + if p.GetParseListeners() != nil { + p.TriggerExitRuleEvent() + } + _prevctx = localctx + p.SetState(7411) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1089, p.GetParserRuleContext()) { + case 1: + localctx = NewBitExpressionAtomContext(p, NewExpressionAtomContext(p, _parentctx, _parentState)) + localctx.(*BitExpressionAtomContext).left = _prevctx + + p.PushNewRecursionContext(localctx, _startState, MySqlParserRULE_expressionAtom) + p.SetState(7392) + + if !(p.Precpred(p.GetParserRuleContext(), 4)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 4)", "")) + goto errorExit + } + { + p.SetState(7393) + p.BitOperator() + } + { + p.SetState(7394) + + var _x = p.expressionAtom(5) + + localctx.(*BitExpressionAtomContext).right = _x + } + + case 2: + localctx = NewMathExpressionAtomContext(p, NewExpressionAtomContext(p, _parentctx, _parentState)) + localctx.(*MathExpressionAtomContext).left = _prevctx + + p.PushNewRecursionContext(localctx, _startState, MySqlParserRULE_expressionAtom) + p.SetState(7396) + + if !(p.Precpred(p.GetParserRuleContext(), 3)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 3)", "")) + goto errorExit + } + { + p.SetState(7397) + p.MultOperator() + } + { + p.SetState(7398) + + var _x = p.expressionAtom(4) + + localctx.(*MathExpressionAtomContext).right = _x + } + + case 3: + localctx = NewMathExpressionAtomContext(p, NewExpressionAtomContext(p, _parentctx, _parentState)) + localctx.(*MathExpressionAtomContext).left = _prevctx + + p.PushNewRecursionContext(localctx, _startState, MySqlParserRULE_expressionAtom) + p.SetState(7400) + + if !(p.Precpred(p.GetParserRuleContext(), 2)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 2)", "")) + goto errorExit + } + { + p.SetState(7401) + p.AddOperator() + } + { + p.SetState(7402) + + var _x = p.expressionAtom(3) + + localctx.(*MathExpressionAtomContext).right = _x + } + + case 4: + localctx = NewJsonExpressionAtomContext(p, NewExpressionAtomContext(p, _parentctx, _parentState)) + localctx.(*JsonExpressionAtomContext).left = _prevctx + + p.PushNewRecursionContext(localctx, _startState, MySqlParserRULE_expressionAtom) + p.SetState(7404) + + if !(p.Precpred(p.GetParserRuleContext(), 1)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", "")) + goto errorExit + } + { + p.SetState(7405) + p.JsonOperator() + } + { + p.SetState(7406) + + var _x = p.expressionAtom(2) + + localctx.(*JsonExpressionAtomContext).right = _x + } + + case 5: + localctx = NewCollateExpressionAtomContext(p, NewExpressionAtomContext(p, _parentctx, _parentState)) + p.PushNewRecursionContext(localctx, _startState, MySqlParserRULE_expressionAtom) + p.SetState(7408) + + if !(p.Precpred(p.GetParserRuleContext(), 14)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 14)", "")) + goto errorExit + } + { + p.SetState(7409) + p.Match(MySqlParserCOLLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7410) + p.CollationName() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + p.SetState(7415) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1090, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.UnrollRecursionContexts(_parentctx) + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUnaryOperatorContext is an interface to support dynamic dispatch. +type IUnaryOperatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXCLAMATION_SYMBOL() antlr.TerminalNode + BIT_NOT_OP() antlr.TerminalNode + PLUS() antlr.TerminalNode + MINUS() antlr.TerminalNode + NOT() antlr.TerminalNode + + // IsUnaryOperatorContext differentiates from other interfaces. + IsUnaryOperatorContext() +} + +type UnaryOperatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUnaryOperatorContext() *UnaryOperatorContext { + var p = new(UnaryOperatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_unaryOperator + return p +} + +func InitEmptyUnaryOperatorContext(p *UnaryOperatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_unaryOperator +} + +func (*UnaryOperatorContext) IsUnaryOperatorContext() {} + +func NewUnaryOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnaryOperatorContext { + var p = new(UnaryOperatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_unaryOperator + + return p +} + +func (s *UnaryOperatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *UnaryOperatorContext) EXCLAMATION_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEXCLAMATION_SYMBOL, 0) +} + +func (s *UnaryOperatorContext) BIT_NOT_OP() antlr.TerminalNode { + return s.GetToken(MySqlParserBIT_NOT_OP, 0) +} + +func (s *UnaryOperatorContext) PLUS() antlr.TerminalNode { + return s.GetToken(MySqlParserPLUS, 0) +} + +func (s *UnaryOperatorContext) MINUS() antlr.TerminalNode { + return s.GetToken(MySqlParserMINUS, 0) +} + +func (s *UnaryOperatorContext) NOT() antlr.TerminalNode { + return s.GetToken(MySqlParserNOT, 0) +} + +func (s *UnaryOperatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UnaryOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *UnaryOperatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterUnaryOperator(s) + } +} + +func (s *UnaryOperatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitUnaryOperator(s) + } +} + +func (p *MySqlParser) UnaryOperator() (localctx IUnaryOperatorContext) { + localctx = NewUnaryOperatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 694, MySqlParserRULE_unaryOperator) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7416) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserNOT || ((int64((_la-1125)) & ^0x3f) == 0 && ((int64(1)<<(_la-1125))&387) != 0)) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IComparisonOperatorContext is an interface to support dynamic dispatch. +type IComparisonOperatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EQUAL_SYMBOL() antlr.TerminalNode + GREATER_SYMBOL() antlr.TerminalNode + LESS_SYMBOL() antlr.TerminalNode + EXCLAMATION_SYMBOL() antlr.TerminalNode + + // IsComparisonOperatorContext differentiates from other interfaces. + IsComparisonOperatorContext() +} + +type ComparisonOperatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyComparisonOperatorContext() *ComparisonOperatorContext { + var p = new(ComparisonOperatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_comparisonOperator + return p +} + +func InitEmptyComparisonOperatorContext(p *ComparisonOperatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_comparisonOperator +} + +func (*ComparisonOperatorContext) IsComparisonOperatorContext() {} + +func NewComparisonOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ComparisonOperatorContext { + var p = new(ComparisonOperatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_comparisonOperator + + return p +} + +func (s *ComparisonOperatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *ComparisonOperatorContext) EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUAL_SYMBOL, 0) +} + +func (s *ComparisonOperatorContext) GREATER_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserGREATER_SYMBOL, 0) +} + +func (s *ComparisonOperatorContext) LESS_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserLESS_SYMBOL, 0) +} + +func (s *ComparisonOperatorContext) EXCLAMATION_SYMBOL() antlr.TerminalNode { + return s.GetToken(MySqlParserEXCLAMATION_SYMBOL, 0) +} + +func (s *ComparisonOperatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ComparisonOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ComparisonOperatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterComparisonOperator(s) + } +} + +func (s *ComparisonOperatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitComparisonOperator(s) + } +} + +func (p *MySqlParser) ComparisonOperator() (localctx IComparisonOperatorContext) { + localctx = NewComparisonOperatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 696, MySqlParserRULE_comparisonOperator) + p.SetState(7432) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1091, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7418) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7419) + p.Match(MySqlParserGREATER_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(7420) + p.Match(MySqlParserLESS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(7421) + p.Match(MySqlParserLESS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7422) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(7423) + p.Match(MySqlParserGREATER_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7424) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(7425) + p.Match(MySqlParserLESS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7426) + p.Match(MySqlParserGREATER_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(7427) + p.Match(MySqlParserEXCLAMATION_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7428) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(7429) + p.Match(MySqlParserLESS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7430) + p.Match(MySqlParserEQUAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7431) + p.Match(MySqlParserGREATER_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILogicalOperatorContext is an interface to support dynamic dispatch. +type ILogicalOperatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AND() antlr.TerminalNode + AllBIT_AND_OP() []antlr.TerminalNode + BIT_AND_OP(i int) antlr.TerminalNode + XOR() antlr.TerminalNode + OR() antlr.TerminalNode + AllBIT_OR_OP() []antlr.TerminalNode + BIT_OR_OP(i int) antlr.TerminalNode + + // IsLogicalOperatorContext differentiates from other interfaces. + IsLogicalOperatorContext() +} + +type LogicalOperatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLogicalOperatorContext() *LogicalOperatorContext { + var p = new(LogicalOperatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_logicalOperator + return p +} + +func InitEmptyLogicalOperatorContext(p *LogicalOperatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_logicalOperator +} + +func (*LogicalOperatorContext) IsLogicalOperatorContext() {} + +func NewLogicalOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LogicalOperatorContext { + var p = new(LogicalOperatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_logicalOperator + + return p +} + +func (s *LogicalOperatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *LogicalOperatorContext) AND() antlr.TerminalNode { + return s.GetToken(MySqlParserAND, 0) +} + +func (s *LogicalOperatorContext) AllBIT_AND_OP() []antlr.TerminalNode { + return s.GetTokens(MySqlParserBIT_AND_OP) +} + +func (s *LogicalOperatorContext) BIT_AND_OP(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserBIT_AND_OP, i) +} + +func (s *LogicalOperatorContext) XOR() antlr.TerminalNode { + return s.GetToken(MySqlParserXOR, 0) +} + +func (s *LogicalOperatorContext) OR() antlr.TerminalNode { + return s.GetToken(MySqlParserOR, 0) +} + +func (s *LogicalOperatorContext) AllBIT_OR_OP() []antlr.TerminalNode { + return s.GetTokens(MySqlParserBIT_OR_OP) +} + +func (s *LogicalOperatorContext) BIT_OR_OP(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserBIT_OR_OP, i) +} + +func (s *LogicalOperatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LogicalOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *LogicalOperatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterLogicalOperator(s) + } +} + +func (s *LogicalOperatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitLogicalOperator(s) + } +} + +func (p *MySqlParser) LogicalOperator() (localctx ILogicalOperatorContext) { + localctx = NewLogicalOperatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 698, MySqlParserRULE_logicalOperator) + p.SetState(7441) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserAND: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7434) + p.Match(MySqlParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserBIT_AND_OP: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7435) + p.Match(MySqlParserBIT_AND_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7436) + p.Match(MySqlParserBIT_AND_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserXOR: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(7437) + p.Match(MySqlParserXOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserOR: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(7438) + p.Match(MySqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserBIT_OR_OP: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(7439) + p.Match(MySqlParserBIT_OR_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7440) + p.Match(MySqlParserBIT_OR_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBitOperatorContext is an interface to support dynamic dispatch. +type IBitOperatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllLESS_SYMBOL() []antlr.TerminalNode + LESS_SYMBOL(i int) antlr.TerminalNode + AllGREATER_SYMBOL() []antlr.TerminalNode + GREATER_SYMBOL(i int) antlr.TerminalNode + BIT_AND_OP() antlr.TerminalNode + BIT_XOR_OP() antlr.TerminalNode + BIT_OR_OP() antlr.TerminalNode + + // IsBitOperatorContext differentiates from other interfaces. + IsBitOperatorContext() +} + +type BitOperatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBitOperatorContext() *BitOperatorContext { + var p = new(BitOperatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_bitOperator + return p +} + +func InitEmptyBitOperatorContext(p *BitOperatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_bitOperator +} + +func (*BitOperatorContext) IsBitOperatorContext() {} + +func NewBitOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BitOperatorContext { + var p = new(BitOperatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_bitOperator + + return p +} + +func (s *BitOperatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *BitOperatorContext) AllLESS_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(MySqlParserLESS_SYMBOL) +} + +func (s *BitOperatorContext) LESS_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserLESS_SYMBOL, i) +} + +func (s *BitOperatorContext) AllGREATER_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(MySqlParserGREATER_SYMBOL) +} + +func (s *BitOperatorContext) GREATER_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserGREATER_SYMBOL, i) +} + +func (s *BitOperatorContext) BIT_AND_OP() antlr.TerminalNode { + return s.GetToken(MySqlParserBIT_AND_OP, 0) +} + +func (s *BitOperatorContext) BIT_XOR_OP() antlr.TerminalNode { + return s.GetToken(MySqlParserBIT_XOR_OP, 0) +} + +func (s *BitOperatorContext) BIT_OR_OP() antlr.TerminalNode { + return s.GetToken(MySqlParserBIT_OR_OP, 0) +} + +func (s *BitOperatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *BitOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *BitOperatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterBitOperator(s) + } +} + +func (s *BitOperatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitBitOperator(s) + } +} + +func (p *MySqlParser) BitOperator() (localctx IBitOperatorContext) { + localctx = NewBitOperatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 700, MySqlParserRULE_bitOperator) + p.SetState(7450) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MySqlParserLESS_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7443) + p.Match(MySqlParserLESS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7444) + p.Match(MySqlParserLESS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserGREATER_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7445) + p.Match(MySqlParserGREATER_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7446) + p.Match(MySqlParserGREATER_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserBIT_AND_OP: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(7447) + p.Match(MySqlParserBIT_AND_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserBIT_XOR_OP: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(7448) + p.Match(MySqlParserBIT_XOR_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case MySqlParserBIT_OR_OP: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(7449) + p.Match(MySqlParserBIT_OR_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMultOperatorContext is an interface to support dynamic dispatch. +type IMultOperatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + STAR() antlr.TerminalNode + DIVIDE() antlr.TerminalNode + MODULE() antlr.TerminalNode + DIV() antlr.TerminalNode + MOD() antlr.TerminalNode + + // IsMultOperatorContext differentiates from other interfaces. + IsMultOperatorContext() +} + +type MultOperatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMultOperatorContext() *MultOperatorContext { + var p = new(MultOperatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_multOperator + return p +} + +func InitEmptyMultOperatorContext(p *MultOperatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_multOperator +} + +func (*MultOperatorContext) IsMultOperatorContext() {} + +func NewMultOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MultOperatorContext { + var p = new(MultOperatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_multOperator + + return p +} + +func (s *MultOperatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *MultOperatorContext) STAR() antlr.TerminalNode { + return s.GetToken(MySqlParserSTAR, 0) +} + +func (s *MultOperatorContext) DIVIDE() antlr.TerminalNode { + return s.GetToken(MySqlParserDIVIDE, 0) +} + +func (s *MultOperatorContext) MODULE() antlr.TerminalNode { + return s.GetToken(MySqlParserMODULE, 0) +} + +func (s *MultOperatorContext) DIV() antlr.TerminalNode { + return s.GetToken(MySqlParserDIV, 0) +} + +func (s *MultOperatorContext) MOD() antlr.TerminalNode { + return s.GetToken(MySqlParserMOD, 0) +} + +func (s *MultOperatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MultOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *MultOperatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterMultOperator(s) + } +} + +func (s *MultOperatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitMultOperator(s) + } +} + +func (p *MySqlParser) MultOperator() (localctx IMultOperatorContext) { + localctx = NewMultOperatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 702, MySqlParserRULE_multOperator) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7452) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-1122)) & ^0x3f) == 0 && ((int64(1)<<(_la-1122))&103) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAddOperatorContext is an interface to support dynamic dispatch. +type IAddOperatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PLUS() antlr.TerminalNode + MINUS() antlr.TerminalNode + + // IsAddOperatorContext differentiates from other interfaces. + IsAddOperatorContext() +} + +type AddOperatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAddOperatorContext() *AddOperatorContext { + var p = new(AddOperatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_addOperator + return p +} + +func InitEmptyAddOperatorContext(p *AddOperatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_addOperator +} + +func (*AddOperatorContext) IsAddOperatorContext() {} + +func NewAddOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AddOperatorContext { + var p = new(AddOperatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_addOperator + + return p +} + +func (s *AddOperatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *AddOperatorContext) PLUS() antlr.TerminalNode { + return s.GetToken(MySqlParserPLUS, 0) +} + +func (s *AddOperatorContext) MINUS() antlr.TerminalNode { + return s.GetToken(MySqlParserMINUS, 0) +} + +func (s *AddOperatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AddOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AddOperatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterAddOperator(s) + } +} + +func (s *AddOperatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitAddOperator(s) + } +} + +func (p *MySqlParser) AddOperator() (localctx IAddOperatorContext) { + localctx = NewAddOperatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 704, MySqlParserRULE_addOperator) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7454) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserPLUS || _la == MySqlParserMINUS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJsonOperatorContext is an interface to support dynamic dispatch. +type IJsonOperatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MINUS() antlr.TerminalNode + AllGREATER_SYMBOL() []antlr.TerminalNode + GREATER_SYMBOL(i int) antlr.TerminalNode + + // IsJsonOperatorContext differentiates from other interfaces. + IsJsonOperatorContext() +} + +type JsonOperatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJsonOperatorContext() *JsonOperatorContext { + var p = new(JsonOperatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_jsonOperator + return p +} + +func InitEmptyJsonOperatorContext(p *JsonOperatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_jsonOperator +} + +func (*JsonOperatorContext) IsJsonOperatorContext() {} + +func NewJsonOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *JsonOperatorContext { + var p = new(JsonOperatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_jsonOperator + + return p +} + +func (s *JsonOperatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *JsonOperatorContext) MINUS() antlr.TerminalNode { + return s.GetToken(MySqlParserMINUS, 0) +} + +func (s *JsonOperatorContext) AllGREATER_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(MySqlParserGREATER_SYMBOL) +} + +func (s *JsonOperatorContext) GREATER_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(MySqlParserGREATER_SYMBOL, i) +} + +func (s *JsonOperatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *JsonOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *JsonOperatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterJsonOperator(s) + } +} + +func (s *JsonOperatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitJsonOperator(s) + } +} + +func (p *MySqlParser) JsonOperator() (localctx IJsonOperatorContext) { + localctx = NewJsonOperatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 706, MySqlParserRULE_jsonOperator) + p.SetState(7461) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1094, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7456) + p.Match(MySqlParserMINUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7457) + p.Match(MySqlParserGREATER_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7458) + p.Match(MySqlParserMINUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7459) + p.Match(MySqlParserGREATER_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7460) + p.Match(MySqlParserGREATER_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICharsetNameBaseContext is an interface to support dynamic dispatch. +type ICharsetNameBaseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ARMSCII8() antlr.TerminalNode + ASCII() antlr.TerminalNode + BIG5() antlr.TerminalNode + BINARY() antlr.TerminalNode + CP1250() antlr.TerminalNode + CP1251() antlr.TerminalNode + CP1256() antlr.TerminalNode + CP1257() antlr.TerminalNode + CP850() antlr.TerminalNode + CP852() antlr.TerminalNode + CP866() antlr.TerminalNode + CP932() antlr.TerminalNode + DEC8() antlr.TerminalNode + EUCJPMS() antlr.TerminalNode + EUCKR() antlr.TerminalNode + GB18030() antlr.TerminalNode + GB2312() antlr.TerminalNode + GBK() antlr.TerminalNode + GEOSTD8() antlr.TerminalNode + GREEK() antlr.TerminalNode + HEBREW() antlr.TerminalNode + HP8() antlr.TerminalNode + KEYBCS2() antlr.TerminalNode + KOI8R() antlr.TerminalNode + KOI8U() antlr.TerminalNode + LATIN1() antlr.TerminalNode + LATIN2() antlr.TerminalNode + LATIN5() antlr.TerminalNode + LATIN7() antlr.TerminalNode + MACCE() antlr.TerminalNode + MACROMAN() antlr.TerminalNode + SJIS() antlr.TerminalNode + SWE7() antlr.TerminalNode + TIS620() antlr.TerminalNode + UCS2() antlr.TerminalNode + UJIS() antlr.TerminalNode + UTF16() antlr.TerminalNode + UTF16LE() antlr.TerminalNode + UTF32() antlr.TerminalNode + UTF8() antlr.TerminalNode + UTF8MB3() antlr.TerminalNode + UTF8MB4() antlr.TerminalNode + + // IsCharsetNameBaseContext differentiates from other interfaces. + IsCharsetNameBaseContext() +} + +type CharsetNameBaseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCharsetNameBaseContext() *CharsetNameBaseContext { + var p = new(CharsetNameBaseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_charsetNameBase + return p +} + +func InitEmptyCharsetNameBaseContext(p *CharsetNameBaseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_charsetNameBase +} + +func (*CharsetNameBaseContext) IsCharsetNameBaseContext() {} + +func NewCharsetNameBaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CharsetNameBaseContext { + var p = new(CharsetNameBaseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_charsetNameBase + + return p +} + +func (s *CharsetNameBaseContext) GetParser() antlr.Parser { return s.parser } + +func (s *CharsetNameBaseContext) ARMSCII8() antlr.TerminalNode { + return s.GetToken(MySqlParserARMSCII8, 0) +} + +func (s *CharsetNameBaseContext) ASCII() antlr.TerminalNode { + return s.GetToken(MySqlParserASCII, 0) +} + +func (s *CharsetNameBaseContext) BIG5() antlr.TerminalNode { + return s.GetToken(MySqlParserBIG5, 0) +} + +func (s *CharsetNameBaseContext) BINARY() antlr.TerminalNode { + return s.GetToken(MySqlParserBINARY, 0) +} + +func (s *CharsetNameBaseContext) CP1250() antlr.TerminalNode { + return s.GetToken(MySqlParserCP1250, 0) +} + +func (s *CharsetNameBaseContext) CP1251() antlr.TerminalNode { + return s.GetToken(MySqlParserCP1251, 0) +} + +func (s *CharsetNameBaseContext) CP1256() antlr.TerminalNode { + return s.GetToken(MySqlParserCP1256, 0) +} + +func (s *CharsetNameBaseContext) CP1257() antlr.TerminalNode { + return s.GetToken(MySqlParserCP1257, 0) +} + +func (s *CharsetNameBaseContext) CP850() antlr.TerminalNode { + return s.GetToken(MySqlParserCP850, 0) +} + +func (s *CharsetNameBaseContext) CP852() antlr.TerminalNode { + return s.GetToken(MySqlParserCP852, 0) +} + +func (s *CharsetNameBaseContext) CP866() antlr.TerminalNode { + return s.GetToken(MySqlParserCP866, 0) +} + +func (s *CharsetNameBaseContext) CP932() antlr.TerminalNode { + return s.GetToken(MySqlParserCP932, 0) +} + +func (s *CharsetNameBaseContext) DEC8() antlr.TerminalNode { + return s.GetToken(MySqlParserDEC8, 0) +} + +func (s *CharsetNameBaseContext) EUCJPMS() antlr.TerminalNode { + return s.GetToken(MySqlParserEUCJPMS, 0) +} + +func (s *CharsetNameBaseContext) EUCKR() antlr.TerminalNode { + return s.GetToken(MySqlParserEUCKR, 0) +} + +func (s *CharsetNameBaseContext) GB18030() antlr.TerminalNode { + return s.GetToken(MySqlParserGB18030, 0) +} + +func (s *CharsetNameBaseContext) GB2312() antlr.TerminalNode { + return s.GetToken(MySqlParserGB2312, 0) +} + +func (s *CharsetNameBaseContext) GBK() antlr.TerminalNode { + return s.GetToken(MySqlParserGBK, 0) +} + +func (s *CharsetNameBaseContext) GEOSTD8() antlr.TerminalNode { + return s.GetToken(MySqlParserGEOSTD8, 0) +} + +func (s *CharsetNameBaseContext) GREEK() antlr.TerminalNode { + return s.GetToken(MySqlParserGREEK, 0) +} + +func (s *CharsetNameBaseContext) HEBREW() antlr.TerminalNode { + return s.GetToken(MySqlParserHEBREW, 0) +} + +func (s *CharsetNameBaseContext) HP8() antlr.TerminalNode { + return s.GetToken(MySqlParserHP8, 0) +} + +func (s *CharsetNameBaseContext) KEYBCS2() antlr.TerminalNode { + return s.GetToken(MySqlParserKEYBCS2, 0) +} + +func (s *CharsetNameBaseContext) KOI8R() antlr.TerminalNode { + return s.GetToken(MySqlParserKOI8R, 0) +} + +func (s *CharsetNameBaseContext) KOI8U() antlr.TerminalNode { + return s.GetToken(MySqlParserKOI8U, 0) +} + +func (s *CharsetNameBaseContext) LATIN1() antlr.TerminalNode { + return s.GetToken(MySqlParserLATIN1, 0) +} + +func (s *CharsetNameBaseContext) LATIN2() antlr.TerminalNode { + return s.GetToken(MySqlParserLATIN2, 0) +} + +func (s *CharsetNameBaseContext) LATIN5() antlr.TerminalNode { + return s.GetToken(MySqlParserLATIN5, 0) +} + +func (s *CharsetNameBaseContext) LATIN7() antlr.TerminalNode { + return s.GetToken(MySqlParserLATIN7, 0) +} + +func (s *CharsetNameBaseContext) MACCE() antlr.TerminalNode { + return s.GetToken(MySqlParserMACCE, 0) +} + +func (s *CharsetNameBaseContext) MACROMAN() antlr.TerminalNode { + return s.GetToken(MySqlParserMACROMAN, 0) +} + +func (s *CharsetNameBaseContext) SJIS() antlr.TerminalNode { + return s.GetToken(MySqlParserSJIS, 0) +} + +func (s *CharsetNameBaseContext) SWE7() antlr.TerminalNode { + return s.GetToken(MySqlParserSWE7, 0) +} + +func (s *CharsetNameBaseContext) TIS620() antlr.TerminalNode { + return s.GetToken(MySqlParserTIS620, 0) +} + +func (s *CharsetNameBaseContext) UCS2() antlr.TerminalNode { + return s.GetToken(MySqlParserUCS2, 0) +} + +func (s *CharsetNameBaseContext) UJIS() antlr.TerminalNode { + return s.GetToken(MySqlParserUJIS, 0) +} + +func (s *CharsetNameBaseContext) UTF16() antlr.TerminalNode { + return s.GetToken(MySqlParserUTF16, 0) +} + +func (s *CharsetNameBaseContext) UTF16LE() antlr.TerminalNode { + return s.GetToken(MySqlParserUTF16LE, 0) +} + +func (s *CharsetNameBaseContext) UTF32() antlr.TerminalNode { + return s.GetToken(MySqlParserUTF32, 0) +} + +func (s *CharsetNameBaseContext) UTF8() antlr.TerminalNode { + return s.GetToken(MySqlParserUTF8, 0) +} + +func (s *CharsetNameBaseContext) UTF8MB3() antlr.TerminalNode { + return s.GetToken(MySqlParserUTF8MB3, 0) +} + +func (s *CharsetNameBaseContext) UTF8MB4() antlr.TerminalNode { + return s.GetToken(MySqlParserUTF8MB4, 0) +} + +func (s *CharsetNameBaseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CharsetNameBaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CharsetNameBaseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterCharsetNameBase(s) + } +} + +func (s *CharsetNameBaseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitCharsetNameBase(s) + } +} + +func (p *MySqlParser) CharsetNameBase() (localctx ICharsetNameBaseContext) { + localctx = NewCharsetNameBaseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 708, MySqlParserRULE_charsetNameBase) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7463) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserBINARY || ((int64((_la-747)) & ^0x3f) == 0 && ((int64(1)<<(_la-747))&2199023255551) != 0)) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITransactionLevelBaseContext is an interface to support dynamic dispatch. +type ITransactionLevelBaseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REPEATABLE() antlr.TerminalNode + COMMITTED() antlr.TerminalNode + UNCOMMITTED() antlr.TerminalNode + SERIALIZABLE() antlr.TerminalNode + + // IsTransactionLevelBaseContext differentiates from other interfaces. + IsTransactionLevelBaseContext() +} + +type TransactionLevelBaseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTransactionLevelBaseContext() *TransactionLevelBaseContext { + var p = new(TransactionLevelBaseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_transactionLevelBase + return p +} + +func InitEmptyTransactionLevelBaseContext(p *TransactionLevelBaseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_transactionLevelBase +} + +func (*TransactionLevelBaseContext) IsTransactionLevelBaseContext() {} + +func NewTransactionLevelBaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TransactionLevelBaseContext { + var p = new(TransactionLevelBaseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_transactionLevelBase + + return p +} + +func (s *TransactionLevelBaseContext) GetParser() antlr.Parser { return s.parser } + +func (s *TransactionLevelBaseContext) REPEATABLE() antlr.TerminalNode { + return s.GetToken(MySqlParserREPEATABLE, 0) +} + +func (s *TransactionLevelBaseContext) COMMITTED() antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMITTED, 0) +} + +func (s *TransactionLevelBaseContext) UNCOMMITTED() antlr.TerminalNode { + return s.GetToken(MySqlParserUNCOMMITTED, 0) +} + +func (s *TransactionLevelBaseContext) SERIALIZABLE() antlr.TerminalNode { + return s.GetToken(MySqlParserSERIALIZABLE, 0) +} + +func (s *TransactionLevelBaseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TransactionLevelBaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TransactionLevelBaseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterTransactionLevelBase(s) + } +} + +func (s *TransactionLevelBaseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitTransactionLevelBase(s) + } +} + +func (p *MySqlParser) TransactionLevelBase() (localctx ITransactionLevelBaseContext) { + localctx = NewTransactionLevelBaseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 710, MySqlParserRULE_transactionLevelBase) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7465) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-800)) & ^0x3f) == 0 && ((int64(1)<<(_la-800))&15) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPrivilegesBaseContext is an interface to support dynamic dispatch. +type IPrivilegesBaseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TABLES() antlr.TerminalNode + ROUTINE() antlr.TerminalNode + EXECUTE() antlr.TerminalNode + FILE() antlr.TerminalNode + PROCESS() antlr.TerminalNode + RELOAD() antlr.TerminalNode + SHUTDOWN() antlr.TerminalNode + SUPER() antlr.TerminalNode + PRIVILEGES() antlr.TerminalNode + + // IsPrivilegesBaseContext differentiates from other interfaces. + IsPrivilegesBaseContext() +} + +type PrivilegesBaseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPrivilegesBaseContext() *PrivilegesBaseContext { + var p = new(PrivilegesBaseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_privilegesBase + return p +} + +func InitEmptyPrivilegesBaseContext(p *PrivilegesBaseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_privilegesBase +} + +func (*PrivilegesBaseContext) IsPrivilegesBaseContext() {} + +func NewPrivilegesBaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrivilegesBaseContext { + var p = new(PrivilegesBaseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_privilegesBase + + return p +} + +func (s *PrivilegesBaseContext) GetParser() antlr.Parser { return s.parser } + +func (s *PrivilegesBaseContext) TABLES() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLES, 0) +} + +func (s *PrivilegesBaseContext) ROUTINE() antlr.TerminalNode { + return s.GetToken(MySqlParserROUTINE, 0) +} + +func (s *PrivilegesBaseContext) EXECUTE() antlr.TerminalNode { + return s.GetToken(MySqlParserEXECUTE, 0) +} + +func (s *PrivilegesBaseContext) FILE() antlr.TerminalNode { + return s.GetToken(MySqlParserFILE, 0) +} + +func (s *PrivilegesBaseContext) PROCESS() antlr.TerminalNode { + return s.GetToken(MySqlParserPROCESS, 0) +} + +func (s *PrivilegesBaseContext) RELOAD() antlr.TerminalNode { + return s.GetToken(MySqlParserRELOAD, 0) +} + +func (s *PrivilegesBaseContext) SHUTDOWN() antlr.TerminalNode { + return s.GetToken(MySqlParserSHUTDOWN, 0) +} + +func (s *PrivilegesBaseContext) SUPER() antlr.TerminalNode { + return s.GetToken(MySqlParserSUPER, 0) +} + +func (s *PrivilegesBaseContext) PRIVILEGES() antlr.TerminalNode { + return s.GetToken(MySqlParserPRIVILEGES, 0) +} + +func (s *PrivilegesBaseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PrivilegesBaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PrivilegesBaseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterPrivilegesBase(s) + } +} + +func (s *PrivilegesBaseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitPrivilegesBase(s) + } +} + +func (p *MySqlParser) PrivilegesBase() (localctx IPrivilegesBaseContext) { + localctx = NewPrivilegesBaseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 712, MySqlParserRULE_privilegesBase) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7467) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-709)) & ^0x3f) == 0 && ((int64(1)<<(_la-709))&23656792067) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIntervalTypeBaseContext is an interface to support dynamic dispatch. +type IIntervalTypeBaseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + QUARTER() antlr.TerminalNode + MONTH() antlr.TerminalNode + DAY() antlr.TerminalNode + HOUR() antlr.TerminalNode + MINUTE() antlr.TerminalNode + WEEK() antlr.TerminalNode + SECOND() antlr.TerminalNode + MICROSECOND() antlr.TerminalNode + + // IsIntervalTypeBaseContext differentiates from other interfaces. + IsIntervalTypeBaseContext() +} + +type IntervalTypeBaseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIntervalTypeBaseContext() *IntervalTypeBaseContext { + var p = new(IntervalTypeBaseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_intervalTypeBase + return p +} + +func InitEmptyIntervalTypeBaseContext(p *IntervalTypeBaseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_intervalTypeBase +} + +func (*IntervalTypeBaseContext) IsIntervalTypeBaseContext() {} + +func NewIntervalTypeBaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IntervalTypeBaseContext { + var p = new(IntervalTypeBaseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_intervalTypeBase + + return p +} + +func (s *IntervalTypeBaseContext) GetParser() antlr.Parser { return s.parser } + +func (s *IntervalTypeBaseContext) QUARTER() antlr.TerminalNode { + return s.GetToken(MySqlParserQUARTER, 0) +} + +func (s *IntervalTypeBaseContext) MONTH() antlr.TerminalNode { + return s.GetToken(MySqlParserMONTH, 0) +} + +func (s *IntervalTypeBaseContext) DAY() antlr.TerminalNode { + return s.GetToken(MySqlParserDAY, 0) +} + +func (s *IntervalTypeBaseContext) HOUR() antlr.TerminalNode { + return s.GetToken(MySqlParserHOUR, 0) +} + +func (s *IntervalTypeBaseContext) MINUTE() antlr.TerminalNode { + return s.GetToken(MySqlParserMINUTE, 0) +} + +func (s *IntervalTypeBaseContext) WEEK() antlr.TerminalNode { + return s.GetToken(MySqlParserWEEK, 0) +} + +func (s *IntervalTypeBaseContext) SECOND() antlr.TerminalNode { + return s.GetToken(MySqlParserSECOND, 0) +} + +func (s *IntervalTypeBaseContext) MICROSECOND() antlr.TerminalNode { + return s.GetToken(MySqlParserMICROSECOND, 0) +} + +func (s *IntervalTypeBaseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IntervalTypeBaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IntervalTypeBaseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterIntervalTypeBase(s) + } +} + +func (s *IntervalTypeBaseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitIntervalTypeBase(s) + } +} + +func (p *MySqlParser) IntervalTypeBase() (localctx IIntervalTypeBaseContext) { + localctx = NewIntervalTypeBaseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 714, MySqlParserRULE_intervalTypeBase) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7469) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-690)) & ^0x3f) == 0 && ((int64(1)<<(_la-690))&255) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDataTypeBaseContext is an interface to support dynamic dispatch. +type IDataTypeBaseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DATE() antlr.TerminalNode + TIME() antlr.TerminalNode + TIMESTAMP() antlr.TerminalNode + DATETIME() antlr.TerminalNode + YEAR() antlr.TerminalNode + ENUM() antlr.TerminalNode + TEXT() antlr.TerminalNode + + // IsDataTypeBaseContext differentiates from other interfaces. + IsDataTypeBaseContext() +} + +type DataTypeBaseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDataTypeBaseContext() *DataTypeBaseContext { + var p = new(DataTypeBaseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_dataTypeBase + return p +} + +func InitEmptyDataTypeBaseContext(p *DataTypeBaseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_dataTypeBase +} + +func (*DataTypeBaseContext) IsDataTypeBaseContext() {} + +func NewDataTypeBaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DataTypeBaseContext { + var p = new(DataTypeBaseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_dataTypeBase + + return p +} + +func (s *DataTypeBaseContext) GetParser() antlr.Parser { return s.parser } + +func (s *DataTypeBaseContext) DATE() antlr.TerminalNode { + return s.GetToken(MySqlParserDATE, 0) +} + +func (s *DataTypeBaseContext) TIME() antlr.TerminalNode { + return s.GetToken(MySqlParserTIME, 0) +} + +func (s *DataTypeBaseContext) TIMESTAMP() antlr.TerminalNode { + return s.GetToken(MySqlParserTIMESTAMP, 0) +} + +func (s *DataTypeBaseContext) DATETIME() antlr.TerminalNode { + return s.GetToken(MySqlParserDATETIME, 0) +} + +func (s *DataTypeBaseContext) YEAR() antlr.TerminalNode { + return s.GetToken(MySqlParserYEAR, 0) +} + +func (s *DataTypeBaseContext) ENUM() antlr.TerminalNode { + return s.GetToken(MySqlParserENUM, 0) +} + +func (s *DataTypeBaseContext) TEXT() antlr.TerminalNode { + return s.GetToken(MySqlParserTEXT, 0) +} + +func (s *DataTypeBaseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DataTypeBaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DataTypeBaseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterDataTypeBase(s) + } +} + +func (s *DataTypeBaseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitDataTypeBase(s) + } +} + +func (p *MySqlParser) DataTypeBase() (localctx IDataTypeBaseContext) { + localctx = NewDataTypeBaseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 716, MySqlParserRULE_dataTypeBase) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7471) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&1179679) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKeywordsCanBeIdContext is an interface to support dynamic dispatch. +type IKeywordsCanBeIdContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ACCOUNT() antlr.TerminalNode + ACTION() antlr.TerminalNode + ADMIN() antlr.TerminalNode + AFTER() antlr.TerminalNode + AGGREGATE() antlr.TerminalNode + ALGORITHM() antlr.TerminalNode + ANY() antlr.TerminalNode + ARRAY() antlr.TerminalNode + AT() antlr.TerminalNode + AUDIT_ADMIN() antlr.TerminalNode + AUDIT_ABORT_EXEMPT() antlr.TerminalNode + AUTHORS() antlr.TerminalNode + AUTOCOMMIT() antlr.TerminalNode + AUTOEXTEND_SIZE() antlr.TerminalNode + AUTO_INCREMENT() antlr.TerminalNode + AUTHENTICATION_POLICY_ADMIN() antlr.TerminalNode + AVG() antlr.TerminalNode + AVG_ROW_LENGTH() antlr.TerminalNode + ATTRIBUTE() antlr.TerminalNode + BACKUP_ADMIN() antlr.TerminalNode + BEGIN() antlr.TerminalNode + BINLOG() antlr.TerminalNode + BINLOG_ADMIN() antlr.TerminalNode + BINLOG_ENCRYPTION_ADMIN() antlr.TerminalNode + BIT() antlr.TerminalNode + BIT_AND() antlr.TerminalNode + BIT_OR() antlr.TerminalNode + BIT_XOR() antlr.TerminalNode + BLOCK() antlr.TerminalNode + BOOL() antlr.TerminalNode + BOOLEAN() antlr.TerminalNode + BTREE() antlr.TerminalNode + BUCKETS() antlr.TerminalNode + CACHE() antlr.TerminalNode + CASCADED() antlr.TerminalNode + CHAIN() antlr.TerminalNode + CHANGED() antlr.TerminalNode + CHANNEL() antlr.TerminalNode + CHECKSUM() antlr.TerminalNode + PAGE_CHECKSUM() antlr.TerminalNode + CATALOG_NAME() antlr.TerminalNode + CIPHER() antlr.TerminalNode + CLASS_ORIGIN() antlr.TerminalNode + CLIENT() antlr.TerminalNode + CLONE_ADMIN() antlr.TerminalNode + CLOSE() antlr.TerminalNode + CLUSTERING() antlr.TerminalNode + COALESCE() antlr.TerminalNode + CODE() antlr.TerminalNode + COLUMNS() antlr.TerminalNode + COLUMN_FORMAT() antlr.TerminalNode + COLUMN_NAME() antlr.TerminalNode + COMMENT() antlr.TerminalNode + COMMIT() antlr.TerminalNode + COMPACT() antlr.TerminalNode + COMPLETION() antlr.TerminalNode + COMPRESSED() antlr.TerminalNode + COMPRESSION() antlr.TerminalNode + CONCURRENT() antlr.TerminalNode + CONDITION() antlr.TerminalNode + CONNECT() antlr.TerminalNode + CONNECTION() antlr.TerminalNode + CONNECTION_ADMIN() antlr.TerminalNode + CONSISTENT() antlr.TerminalNode + CONSTRAINT_CATALOG() antlr.TerminalNode + CONSTRAINT_NAME() antlr.TerminalNode + CONSTRAINT_SCHEMA() antlr.TerminalNode + CONTAINS() antlr.TerminalNode + CONTEXT() antlr.TerminalNode + CONTRIBUTORS() antlr.TerminalNode + COPY() antlr.TerminalNode + COUNT() antlr.TerminalNode + CPU() antlr.TerminalNode + CURRENT() antlr.TerminalNode + CURRENT_USER() antlr.TerminalNode + CURSOR_NAME() antlr.TerminalNode + DATA() antlr.TerminalNode + DATAFILE() antlr.TerminalNode + DEALLOCATE() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + DEFAULT_AUTH() antlr.TerminalNode + DEFINER() antlr.TerminalNode + DELAY_KEY_WRITE() antlr.TerminalNode + DES_KEY_FILE() antlr.TerminalNode + DIAGNOSTICS() antlr.TerminalNode + DIRECTORY() antlr.TerminalNode + DISABLE() antlr.TerminalNode + DISCARD() antlr.TerminalNode + DISK() antlr.TerminalNode + DO() antlr.TerminalNode + DUMPFILE() antlr.TerminalNode + DUPLICATE() antlr.TerminalNode + DYNAMIC() antlr.TerminalNode + EMPTY() antlr.TerminalNode + ENABLE() antlr.TerminalNode + ENCRYPTION() antlr.TerminalNode + ENCRYPTION_KEY_ADMIN() antlr.TerminalNode + END() antlr.TerminalNode + ENDS() antlr.TerminalNode + ENGINE() antlr.TerminalNode + ENGINE_ATTRIBUTE() antlr.TerminalNode + ENGINES() antlr.TerminalNode + ENFORCED() antlr.TerminalNode + ERROR() antlr.TerminalNode + ERRORS() antlr.TerminalNode + ESCAPE() antlr.TerminalNode + EUR() antlr.TerminalNode + EVEN() antlr.TerminalNode + EVENT() antlr.TerminalNode + EVENTS() antlr.TerminalNode + EVERY() antlr.TerminalNode + EXCEPT() antlr.TerminalNode + EXCHANGE() antlr.TerminalNode + EXCLUSIVE() antlr.TerminalNode + EXPIRE() antlr.TerminalNode + EXPORT() antlr.TerminalNode + EXTENDED() antlr.TerminalNode + EXTENT_SIZE() antlr.TerminalNode + FAILED_LOGIN_ATTEMPTS() antlr.TerminalNode + FAST() antlr.TerminalNode + FAULTS() antlr.TerminalNode + FIELDS() antlr.TerminalNode + FILE_BLOCK_SIZE() antlr.TerminalNode + FILTER() antlr.TerminalNode + FIREWALL_ADMIN() antlr.TerminalNode + FIREWALL_EXEMPT() antlr.TerminalNode + FIREWALL_USER() antlr.TerminalNode + FIRST() antlr.TerminalNode + FIXED() antlr.TerminalNode + FLUSH() antlr.TerminalNode + FOLLOWS() antlr.TerminalNode + FOUND() antlr.TerminalNode + FULL() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + GENERAL() antlr.TerminalNode + GLOBAL() antlr.TerminalNode + GRANTS() antlr.TerminalNode + GROUP() antlr.TerminalNode + GROUP_CONCAT() antlr.TerminalNode + GROUP_REPLICATION() antlr.TerminalNode + GROUP_REPLICATION_ADMIN() antlr.TerminalNode + HANDLER() antlr.TerminalNode + HASH() antlr.TerminalNode + HELP() antlr.TerminalNode + HISTORY() antlr.TerminalNode + HOST() antlr.TerminalNode + HOSTS() antlr.TerminalNode + IDENTIFIED() antlr.TerminalNode + IGNORED() antlr.TerminalNode + IGNORE_SERVER_IDS() antlr.TerminalNode + IMPORT() antlr.TerminalNode + INDEXES() antlr.TerminalNode + INITIAL_SIZE() antlr.TerminalNode + INNODB_REDO_LOG_ARCHIVE() antlr.TerminalNode + INPLACE() antlr.TerminalNode + INSERT_METHOD() antlr.TerminalNode + INSTALL() antlr.TerminalNode + INSTANCE() antlr.TerminalNode + INSTANT() antlr.TerminalNode + INTERNAL() antlr.TerminalNode + INVOKE() antlr.TerminalNode + INVOKER() antlr.TerminalNode + IO() antlr.TerminalNode + IO_THREAD() antlr.TerminalNode + IPC() antlr.TerminalNode + ISO() antlr.TerminalNode + ISOLATION() antlr.TerminalNode + ISSUER() antlr.TerminalNode + JIS() antlr.TerminalNode + JSON() antlr.TerminalNode + KEY_BLOCK_SIZE() antlr.TerminalNode + LAMBDA() antlr.TerminalNode + LANGUAGE() antlr.TerminalNode + LAST() antlr.TerminalNode + LATERAL() antlr.TerminalNode + LEAVES() antlr.TerminalNode + LESS() antlr.TerminalNode + LEVEL() antlr.TerminalNode + LIST() antlr.TerminalNode + LOCAL() antlr.TerminalNode + LOGFILE() antlr.TerminalNode + LOGS() antlr.TerminalNode + MASTER() antlr.TerminalNode + MASTER_AUTO_POSITION() antlr.TerminalNode + MASTER_CONNECT_RETRY() antlr.TerminalNode + MASTER_DELAY() antlr.TerminalNode + MASTER_HEARTBEAT_PERIOD() antlr.TerminalNode + MASTER_HOST() antlr.TerminalNode + MASTER_LOG_FILE() antlr.TerminalNode + MASTER_LOG_POS() antlr.TerminalNode + MASTER_PASSWORD() antlr.TerminalNode + MASTER_PORT() antlr.TerminalNode + MASTER_RETRY_COUNT() antlr.TerminalNode + MASTER_SSL() antlr.TerminalNode + MASTER_SSL_CA() antlr.TerminalNode + MASTER_SSL_CAPATH() antlr.TerminalNode + MASTER_SSL_CERT() antlr.TerminalNode + MASTER_SSL_CIPHER() antlr.TerminalNode + MASTER_SSL_CRL() antlr.TerminalNode + MASTER_SSL_CRLPATH() antlr.TerminalNode + MASTER_SSL_KEY() antlr.TerminalNode + MASTER_TLS_VERSION() antlr.TerminalNode + MASTER_USER() antlr.TerminalNode + MAX_CONNECTIONS_PER_HOUR() antlr.TerminalNode + MAX_QUERIES_PER_HOUR() antlr.TerminalNode + MAX() antlr.TerminalNode + MAX_ROWS() antlr.TerminalNode + MAX_SIZE() antlr.TerminalNode + MAX_UPDATES_PER_HOUR() antlr.TerminalNode + MAX_USER_CONNECTIONS() antlr.TerminalNode + MEDIUM() antlr.TerminalNode + MEMBER() antlr.TerminalNode + MEMORY() antlr.TerminalNode + MERGE() antlr.TerminalNode + MESSAGE_TEXT() antlr.TerminalNode + MID() antlr.TerminalNode + MIGRATE() antlr.TerminalNode + MIN() antlr.TerminalNode + MIN_ROWS() antlr.TerminalNode + MODE() antlr.TerminalNode + MODIFY() antlr.TerminalNode + MUTEX() antlr.TerminalNode + MYSQL() antlr.TerminalNode + MYSQL_ERRNO() antlr.TerminalNode + NAME() antlr.TerminalNode + NAMES() antlr.TerminalNode + NCHAR() antlr.TerminalNode + NDB_STORED_USER() antlr.TerminalNode + NESTED() antlr.TerminalNode + NEVER() antlr.TerminalNode + NEXT() antlr.TerminalNode + NO() antlr.TerminalNode + NOCOPY() antlr.TerminalNode + NODEGROUP() antlr.TerminalNode + NONE() antlr.TerminalNode + NOWAIT() antlr.TerminalNode + NUMBER() antlr.TerminalNode + ODBC() antlr.TerminalNode + OFFLINE() antlr.TerminalNode + OFFSET() antlr.TerminalNode + OF() antlr.TerminalNode + OJ() antlr.TerminalNode + OLD_PASSWORD() antlr.TerminalNode + ONE() antlr.TerminalNode + ONLINE() antlr.TerminalNode + ONLY() antlr.TerminalNode + OPEN() antlr.TerminalNode + OPTIMIZER_COSTS() antlr.TerminalNode + OPTIONAL() antlr.TerminalNode + OPTIONS() antlr.TerminalNode + ORDER() antlr.TerminalNode + ORDINALITY() antlr.TerminalNode + OWNER() antlr.TerminalNode + PACK_KEYS() antlr.TerminalNode + PAGE() antlr.TerminalNode + PARSER() antlr.TerminalNode + PARTIAL() antlr.TerminalNode + PARTITIONING() antlr.TerminalNode + PARTITIONS() antlr.TerminalNode + PASSWORD() antlr.TerminalNode + PASSWORDLESS_USER_ADMIN() antlr.TerminalNode + PASSWORD_LOCK_TIME() antlr.TerminalNode + PATH() antlr.TerminalNode + PERSIST_RO_VARIABLES_ADMIN() antlr.TerminalNode + PHASE() antlr.TerminalNode + PLUGINS() antlr.TerminalNode + PLUGIN_DIR() antlr.TerminalNode + PLUGIN() antlr.TerminalNode + PORT() antlr.TerminalNode + PRECEDES() antlr.TerminalNode + PREPARE() antlr.TerminalNode + PRESERVE() antlr.TerminalNode + PREV() antlr.TerminalNode + PRIMARY() antlr.TerminalNode + PROCESSLIST() antlr.TerminalNode + PROFILE() antlr.TerminalNode + PROFILES() antlr.TerminalNode + PROXY() antlr.TerminalNode + QUERY() antlr.TerminalNode + QUICK() antlr.TerminalNode + REBUILD() antlr.TerminalNode + RECOVER() antlr.TerminalNode + RECURSIVE() antlr.TerminalNode + REDO_BUFFER_SIZE() antlr.TerminalNode + REDUNDANT() antlr.TerminalNode + RELAY() antlr.TerminalNode + RELAYLOG() antlr.TerminalNode + RELAY_LOG_FILE() antlr.TerminalNode + RELAY_LOG_POS() antlr.TerminalNode + REMOVE() antlr.TerminalNode + REORGANIZE() antlr.TerminalNode + REPAIR() antlr.TerminalNode + REPLICATE_DO_DB() antlr.TerminalNode + REPLICATE_DO_TABLE() antlr.TerminalNode + REPLICATE_IGNORE_DB() antlr.TerminalNode + REPLICATE_IGNORE_TABLE() antlr.TerminalNode + REPLICATE_REWRITE_DB() antlr.TerminalNode + REPLICATE_WILD_DO_TABLE() antlr.TerminalNode + REPLICATE_WILD_IGNORE_TABLE() antlr.TerminalNode + REPLICATION() antlr.TerminalNode + REPLICATION_APPLIER() antlr.TerminalNode + REPLICATION_SLAVE_ADMIN() antlr.TerminalNode + RESET() antlr.TerminalNode + RESOURCE_GROUP_ADMIN() antlr.TerminalNode + RESOURCE_GROUP_USER() antlr.TerminalNode + RESUME() antlr.TerminalNode + RETURNED_SQLSTATE() antlr.TerminalNode + RETURNING() antlr.TerminalNode + RETURNS() antlr.TerminalNode + REUSE() antlr.TerminalNode + ROLE() antlr.TerminalNode + ROLE_ADMIN() antlr.TerminalNode + ROLLBACK() antlr.TerminalNode + ROLLUP() antlr.TerminalNode + ROTATE() antlr.TerminalNode + ROW() antlr.TerminalNode + ROWS() antlr.TerminalNode + ROW_FORMAT() antlr.TerminalNode + RTREE() antlr.TerminalNode + S3() antlr.TerminalNode + SAVEPOINT() antlr.TerminalNode + SCHEDULE() antlr.TerminalNode + SCHEMA_NAME() antlr.TerminalNode + SECURITY() antlr.TerminalNode + SECONDARY_ENGINE_ATTRIBUTE() antlr.TerminalNode + SERIAL() antlr.TerminalNode + SERVER() antlr.TerminalNode + SESSION() antlr.TerminalNode + SESSION_VARIABLES_ADMIN() antlr.TerminalNode + SET_USER_ID() antlr.TerminalNode + SHARE() antlr.TerminalNode + SHARED() antlr.TerminalNode + SHOW_ROUTINE() antlr.TerminalNode + SIGNED() antlr.TerminalNode + SIMPLE() antlr.TerminalNode + SLAVE() antlr.TerminalNode + SLOW() antlr.TerminalNode + SKIP_QUERY_REWRITE() antlr.TerminalNode + SNAPSHOT() antlr.TerminalNode + SOCKET() antlr.TerminalNode + SOME() antlr.TerminalNode + SONAME() antlr.TerminalNode + SOUNDS() antlr.TerminalNode + SOURCE() antlr.TerminalNode + SQL_AFTER_GTIDS() antlr.TerminalNode + SQL_AFTER_MTS_GAPS() antlr.TerminalNode + SQL_BEFORE_GTIDS() antlr.TerminalNode + SQL_BUFFER_RESULT() antlr.TerminalNode + SQL_CACHE() antlr.TerminalNode + SQL_NO_CACHE() antlr.TerminalNode + SQL_THREAD() antlr.TerminalNode + STACKED() antlr.TerminalNode + START() antlr.TerminalNode + STARTS() antlr.TerminalNode + STATS_AUTO_RECALC() antlr.TerminalNode + STATS_PERSISTENT() antlr.TerminalNode + STATS_SAMPLE_PAGES() antlr.TerminalNode + STATUS() antlr.TerminalNode + STD() antlr.TerminalNode + STDDEV() antlr.TerminalNode + STDDEV_POP() antlr.TerminalNode + STDDEV_SAMP() antlr.TerminalNode + STOP() antlr.TerminalNode + STORAGE() antlr.TerminalNode + STRING() antlr.TerminalNode + SUBCLASS_ORIGIN() antlr.TerminalNode + SUBJECT() antlr.TerminalNode + SUBPARTITION() antlr.TerminalNode + SUBPARTITIONS() antlr.TerminalNode + SUM() antlr.TerminalNode + SUSPEND() antlr.TerminalNode + SWAPS() antlr.TerminalNode + SWITCHES() antlr.TerminalNode + SYSTEM_VARIABLES_ADMIN() antlr.TerminalNode + TABLE_NAME() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + TABLE_ENCRYPTION_ADMIN() antlr.TerminalNode + TABLE_TYPE() antlr.TerminalNode + TEMPORARY() antlr.TerminalNode + TEMPTABLE() antlr.TerminalNode + THAN() antlr.TerminalNode + TP_CONNECTION_ADMIN() antlr.TerminalNode + TRADITIONAL() antlr.TerminalNode + TRANSACTION() antlr.TerminalNode + TRANSACTIONAL() antlr.TerminalNode + TRIGGERS() antlr.TerminalNode + TRUNCATE() antlr.TerminalNode + UNBOUNDED() antlr.TerminalNode + UNDEFINED() antlr.TerminalNode + UNDOFILE() antlr.TerminalNode + UNDO_BUFFER_SIZE() antlr.TerminalNode + UNINSTALL() antlr.TerminalNode + UNKNOWN() antlr.TerminalNode + UNTIL() antlr.TerminalNode + UPGRADE() antlr.TerminalNode + USA() antlr.TerminalNode + USER() antlr.TerminalNode + USE_FRM() antlr.TerminalNode + USER_RESOURCES() antlr.TerminalNode + VALIDATION() antlr.TerminalNode + VALUE() antlr.TerminalNode + VAR_POP() antlr.TerminalNode + VAR_SAMP() antlr.TerminalNode + VARIABLES() antlr.TerminalNode + VARIANCE() antlr.TerminalNode + VERSION_TOKEN_ADMIN() antlr.TerminalNode + VIEW() antlr.TerminalNode + VIRTUAL() antlr.TerminalNode + WAIT() antlr.TerminalNode + WARNINGS() antlr.TerminalNode + WITHOUT() antlr.TerminalNode + WORK() antlr.TerminalNode + WRAPPER() antlr.TerminalNode + X509() antlr.TerminalNode + XA() antlr.TerminalNode + XA_RECOVER_ADMIN() antlr.TerminalNode + XML() antlr.TerminalNode + YES() antlr.TerminalNode + + // IsKeywordsCanBeIdContext differentiates from other interfaces. + IsKeywordsCanBeIdContext() +} + +type KeywordsCanBeIdContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKeywordsCanBeIdContext() *KeywordsCanBeIdContext { + var p = new(KeywordsCanBeIdContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_keywordsCanBeId + return p +} + +func InitEmptyKeywordsCanBeIdContext(p *KeywordsCanBeIdContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_keywordsCanBeId +} + +func (*KeywordsCanBeIdContext) IsKeywordsCanBeIdContext() {} + +func NewKeywordsCanBeIdContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KeywordsCanBeIdContext { + var p = new(KeywordsCanBeIdContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_keywordsCanBeId + + return p +} + +func (s *KeywordsCanBeIdContext) GetParser() antlr.Parser { return s.parser } + +func (s *KeywordsCanBeIdContext) ACCOUNT() antlr.TerminalNode { + return s.GetToken(MySqlParserACCOUNT, 0) +} + +func (s *KeywordsCanBeIdContext) ACTION() antlr.TerminalNode { + return s.GetToken(MySqlParserACTION, 0) +} + +func (s *KeywordsCanBeIdContext) ADMIN() antlr.TerminalNode { + return s.GetToken(MySqlParserADMIN, 0) +} + +func (s *KeywordsCanBeIdContext) AFTER() antlr.TerminalNode { + return s.GetToken(MySqlParserAFTER, 0) +} + +func (s *KeywordsCanBeIdContext) AGGREGATE() antlr.TerminalNode { + return s.GetToken(MySqlParserAGGREGATE, 0) +} + +func (s *KeywordsCanBeIdContext) ALGORITHM() antlr.TerminalNode { + return s.GetToken(MySqlParserALGORITHM, 0) +} + +func (s *KeywordsCanBeIdContext) ANY() antlr.TerminalNode { + return s.GetToken(MySqlParserANY, 0) +} + +func (s *KeywordsCanBeIdContext) ARRAY() antlr.TerminalNode { + return s.GetToken(MySqlParserARRAY, 0) +} + +func (s *KeywordsCanBeIdContext) AT() antlr.TerminalNode { + return s.GetToken(MySqlParserAT, 0) +} + +func (s *KeywordsCanBeIdContext) AUDIT_ADMIN() antlr.TerminalNode { + return s.GetToken(MySqlParserAUDIT_ADMIN, 0) +} + +func (s *KeywordsCanBeIdContext) AUDIT_ABORT_EXEMPT() antlr.TerminalNode { + return s.GetToken(MySqlParserAUDIT_ABORT_EXEMPT, 0) +} + +func (s *KeywordsCanBeIdContext) AUTHORS() antlr.TerminalNode { + return s.GetToken(MySqlParserAUTHORS, 0) +} + +func (s *KeywordsCanBeIdContext) AUTOCOMMIT() antlr.TerminalNode { + return s.GetToken(MySqlParserAUTOCOMMIT, 0) +} + +func (s *KeywordsCanBeIdContext) AUTOEXTEND_SIZE() antlr.TerminalNode { + return s.GetToken(MySqlParserAUTOEXTEND_SIZE, 0) +} + +func (s *KeywordsCanBeIdContext) AUTO_INCREMENT() antlr.TerminalNode { + return s.GetToken(MySqlParserAUTO_INCREMENT, 0) +} + +func (s *KeywordsCanBeIdContext) AUTHENTICATION_POLICY_ADMIN() antlr.TerminalNode { + return s.GetToken(MySqlParserAUTHENTICATION_POLICY_ADMIN, 0) +} + +func (s *KeywordsCanBeIdContext) AVG() antlr.TerminalNode { + return s.GetToken(MySqlParserAVG, 0) +} + +func (s *KeywordsCanBeIdContext) AVG_ROW_LENGTH() antlr.TerminalNode { + return s.GetToken(MySqlParserAVG_ROW_LENGTH, 0) +} + +func (s *KeywordsCanBeIdContext) ATTRIBUTE() antlr.TerminalNode { + return s.GetToken(MySqlParserATTRIBUTE, 0) +} + +func (s *KeywordsCanBeIdContext) BACKUP_ADMIN() antlr.TerminalNode { + return s.GetToken(MySqlParserBACKUP_ADMIN, 0) +} + +func (s *KeywordsCanBeIdContext) BEGIN() antlr.TerminalNode { + return s.GetToken(MySqlParserBEGIN, 0) +} + +func (s *KeywordsCanBeIdContext) BINLOG() antlr.TerminalNode { + return s.GetToken(MySqlParserBINLOG, 0) +} + +func (s *KeywordsCanBeIdContext) BINLOG_ADMIN() antlr.TerminalNode { + return s.GetToken(MySqlParserBINLOG_ADMIN, 0) +} + +func (s *KeywordsCanBeIdContext) BINLOG_ENCRYPTION_ADMIN() antlr.TerminalNode { + return s.GetToken(MySqlParserBINLOG_ENCRYPTION_ADMIN, 0) +} + +func (s *KeywordsCanBeIdContext) BIT() antlr.TerminalNode { + return s.GetToken(MySqlParserBIT, 0) +} + +func (s *KeywordsCanBeIdContext) BIT_AND() antlr.TerminalNode { + return s.GetToken(MySqlParserBIT_AND, 0) +} + +func (s *KeywordsCanBeIdContext) BIT_OR() antlr.TerminalNode { + return s.GetToken(MySqlParserBIT_OR, 0) +} + +func (s *KeywordsCanBeIdContext) BIT_XOR() antlr.TerminalNode { + return s.GetToken(MySqlParserBIT_XOR, 0) +} + +func (s *KeywordsCanBeIdContext) BLOCK() antlr.TerminalNode { + return s.GetToken(MySqlParserBLOCK, 0) +} + +func (s *KeywordsCanBeIdContext) BOOL() antlr.TerminalNode { + return s.GetToken(MySqlParserBOOL, 0) +} + +func (s *KeywordsCanBeIdContext) BOOLEAN() antlr.TerminalNode { + return s.GetToken(MySqlParserBOOLEAN, 0) +} + +func (s *KeywordsCanBeIdContext) BTREE() antlr.TerminalNode { + return s.GetToken(MySqlParserBTREE, 0) +} + +func (s *KeywordsCanBeIdContext) BUCKETS() antlr.TerminalNode { + return s.GetToken(MySqlParserBUCKETS, 0) +} + +func (s *KeywordsCanBeIdContext) CACHE() antlr.TerminalNode { + return s.GetToken(MySqlParserCACHE, 0) +} + +func (s *KeywordsCanBeIdContext) CASCADED() antlr.TerminalNode { + return s.GetToken(MySqlParserCASCADED, 0) +} + +func (s *KeywordsCanBeIdContext) CHAIN() antlr.TerminalNode { + return s.GetToken(MySqlParserCHAIN, 0) +} + +func (s *KeywordsCanBeIdContext) CHANGED() antlr.TerminalNode { + return s.GetToken(MySqlParserCHANGED, 0) +} + +func (s *KeywordsCanBeIdContext) CHANNEL() antlr.TerminalNode { + return s.GetToken(MySqlParserCHANNEL, 0) +} + +func (s *KeywordsCanBeIdContext) CHECKSUM() antlr.TerminalNode { + return s.GetToken(MySqlParserCHECKSUM, 0) +} + +func (s *KeywordsCanBeIdContext) PAGE_CHECKSUM() antlr.TerminalNode { + return s.GetToken(MySqlParserPAGE_CHECKSUM, 0) +} + +func (s *KeywordsCanBeIdContext) CATALOG_NAME() antlr.TerminalNode { + return s.GetToken(MySqlParserCATALOG_NAME, 0) +} + +func (s *KeywordsCanBeIdContext) CIPHER() antlr.TerminalNode { + return s.GetToken(MySqlParserCIPHER, 0) +} + +func (s *KeywordsCanBeIdContext) CLASS_ORIGIN() antlr.TerminalNode { + return s.GetToken(MySqlParserCLASS_ORIGIN, 0) +} + +func (s *KeywordsCanBeIdContext) CLIENT() antlr.TerminalNode { + return s.GetToken(MySqlParserCLIENT, 0) +} + +func (s *KeywordsCanBeIdContext) CLONE_ADMIN() antlr.TerminalNode { + return s.GetToken(MySqlParserCLONE_ADMIN, 0) +} + +func (s *KeywordsCanBeIdContext) CLOSE() antlr.TerminalNode { + return s.GetToken(MySqlParserCLOSE, 0) +} + +func (s *KeywordsCanBeIdContext) CLUSTERING() antlr.TerminalNode { + return s.GetToken(MySqlParserCLUSTERING, 0) +} + +func (s *KeywordsCanBeIdContext) COALESCE() antlr.TerminalNode { + return s.GetToken(MySqlParserCOALESCE, 0) +} + +func (s *KeywordsCanBeIdContext) CODE() antlr.TerminalNode { + return s.GetToken(MySqlParserCODE, 0) +} + +func (s *KeywordsCanBeIdContext) COLUMNS() antlr.TerminalNode { + return s.GetToken(MySqlParserCOLUMNS, 0) +} + +func (s *KeywordsCanBeIdContext) COLUMN_FORMAT() antlr.TerminalNode { + return s.GetToken(MySqlParserCOLUMN_FORMAT, 0) +} + +func (s *KeywordsCanBeIdContext) COLUMN_NAME() antlr.TerminalNode { + return s.GetToken(MySqlParserCOLUMN_NAME, 0) +} + +func (s *KeywordsCanBeIdContext) COMMENT() antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMENT, 0) +} + +func (s *KeywordsCanBeIdContext) COMMIT() antlr.TerminalNode { + return s.GetToken(MySqlParserCOMMIT, 0) +} + +func (s *KeywordsCanBeIdContext) COMPACT() antlr.TerminalNode { + return s.GetToken(MySqlParserCOMPACT, 0) +} + +func (s *KeywordsCanBeIdContext) COMPLETION() antlr.TerminalNode { + return s.GetToken(MySqlParserCOMPLETION, 0) +} + +func (s *KeywordsCanBeIdContext) COMPRESSED() antlr.TerminalNode { + return s.GetToken(MySqlParserCOMPRESSED, 0) +} + +func (s *KeywordsCanBeIdContext) COMPRESSION() antlr.TerminalNode { + return s.GetToken(MySqlParserCOMPRESSION, 0) +} + +func (s *KeywordsCanBeIdContext) CONCURRENT() antlr.TerminalNode { + return s.GetToken(MySqlParserCONCURRENT, 0) +} + +func (s *KeywordsCanBeIdContext) CONDITION() antlr.TerminalNode { + return s.GetToken(MySqlParserCONDITION, 0) +} + +func (s *KeywordsCanBeIdContext) CONNECT() antlr.TerminalNode { + return s.GetToken(MySqlParserCONNECT, 0) +} + +func (s *KeywordsCanBeIdContext) CONNECTION() antlr.TerminalNode { + return s.GetToken(MySqlParserCONNECTION, 0) +} + +func (s *KeywordsCanBeIdContext) CONNECTION_ADMIN() antlr.TerminalNode { + return s.GetToken(MySqlParserCONNECTION_ADMIN, 0) +} + +func (s *KeywordsCanBeIdContext) CONSISTENT() antlr.TerminalNode { + return s.GetToken(MySqlParserCONSISTENT, 0) +} + +func (s *KeywordsCanBeIdContext) CONSTRAINT_CATALOG() antlr.TerminalNode { + return s.GetToken(MySqlParserCONSTRAINT_CATALOG, 0) +} + +func (s *KeywordsCanBeIdContext) CONSTRAINT_NAME() antlr.TerminalNode { + return s.GetToken(MySqlParserCONSTRAINT_NAME, 0) +} + +func (s *KeywordsCanBeIdContext) CONSTRAINT_SCHEMA() antlr.TerminalNode { + return s.GetToken(MySqlParserCONSTRAINT_SCHEMA, 0) +} + +func (s *KeywordsCanBeIdContext) CONTAINS() antlr.TerminalNode { + return s.GetToken(MySqlParserCONTAINS, 0) +} + +func (s *KeywordsCanBeIdContext) CONTEXT() antlr.TerminalNode { + return s.GetToken(MySqlParserCONTEXT, 0) +} + +func (s *KeywordsCanBeIdContext) CONTRIBUTORS() antlr.TerminalNode { + return s.GetToken(MySqlParserCONTRIBUTORS, 0) +} + +func (s *KeywordsCanBeIdContext) COPY() antlr.TerminalNode { + return s.GetToken(MySqlParserCOPY, 0) +} + +func (s *KeywordsCanBeIdContext) COUNT() antlr.TerminalNode { + return s.GetToken(MySqlParserCOUNT, 0) +} + +func (s *KeywordsCanBeIdContext) CPU() antlr.TerminalNode { + return s.GetToken(MySqlParserCPU, 0) +} + +func (s *KeywordsCanBeIdContext) CURRENT() antlr.TerminalNode { + return s.GetToken(MySqlParserCURRENT, 0) +} + +func (s *KeywordsCanBeIdContext) CURRENT_USER() antlr.TerminalNode { + return s.GetToken(MySqlParserCURRENT_USER, 0) +} + +func (s *KeywordsCanBeIdContext) CURSOR_NAME() antlr.TerminalNode { + return s.GetToken(MySqlParserCURSOR_NAME, 0) +} + +func (s *KeywordsCanBeIdContext) DATA() antlr.TerminalNode { + return s.GetToken(MySqlParserDATA, 0) +} + +func (s *KeywordsCanBeIdContext) DATAFILE() antlr.TerminalNode { + return s.GetToken(MySqlParserDATAFILE, 0) +} + +func (s *KeywordsCanBeIdContext) DEALLOCATE() antlr.TerminalNode { + return s.GetToken(MySqlParserDEALLOCATE, 0) +} + +func (s *KeywordsCanBeIdContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(MySqlParserDEFAULT, 0) +} + +func (s *KeywordsCanBeIdContext) DEFAULT_AUTH() antlr.TerminalNode { + return s.GetToken(MySqlParserDEFAULT_AUTH, 0) +} + +func (s *KeywordsCanBeIdContext) DEFINER() antlr.TerminalNode { + return s.GetToken(MySqlParserDEFINER, 0) +} + +func (s *KeywordsCanBeIdContext) DELAY_KEY_WRITE() antlr.TerminalNode { + return s.GetToken(MySqlParserDELAY_KEY_WRITE, 0) +} + +func (s *KeywordsCanBeIdContext) DES_KEY_FILE() antlr.TerminalNode { + return s.GetToken(MySqlParserDES_KEY_FILE, 0) +} + +func (s *KeywordsCanBeIdContext) DIAGNOSTICS() antlr.TerminalNode { + return s.GetToken(MySqlParserDIAGNOSTICS, 0) +} + +func (s *KeywordsCanBeIdContext) DIRECTORY() antlr.TerminalNode { + return s.GetToken(MySqlParserDIRECTORY, 0) +} + +func (s *KeywordsCanBeIdContext) DISABLE() antlr.TerminalNode { + return s.GetToken(MySqlParserDISABLE, 0) +} + +func (s *KeywordsCanBeIdContext) DISCARD() antlr.TerminalNode { + return s.GetToken(MySqlParserDISCARD, 0) +} + +func (s *KeywordsCanBeIdContext) DISK() antlr.TerminalNode { + return s.GetToken(MySqlParserDISK, 0) +} + +func (s *KeywordsCanBeIdContext) DO() antlr.TerminalNode { + return s.GetToken(MySqlParserDO, 0) +} + +func (s *KeywordsCanBeIdContext) DUMPFILE() antlr.TerminalNode { + return s.GetToken(MySqlParserDUMPFILE, 0) +} + +func (s *KeywordsCanBeIdContext) DUPLICATE() antlr.TerminalNode { + return s.GetToken(MySqlParserDUPLICATE, 0) +} + +func (s *KeywordsCanBeIdContext) DYNAMIC() antlr.TerminalNode { + return s.GetToken(MySqlParserDYNAMIC, 0) +} + +func (s *KeywordsCanBeIdContext) EMPTY() antlr.TerminalNode { + return s.GetToken(MySqlParserEMPTY, 0) +} + +func (s *KeywordsCanBeIdContext) ENABLE() antlr.TerminalNode { + return s.GetToken(MySqlParserENABLE, 0) +} + +func (s *KeywordsCanBeIdContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(MySqlParserENCRYPTION, 0) +} + +func (s *KeywordsCanBeIdContext) ENCRYPTION_KEY_ADMIN() antlr.TerminalNode { + return s.GetToken(MySqlParserENCRYPTION_KEY_ADMIN, 0) +} + +func (s *KeywordsCanBeIdContext) END() antlr.TerminalNode { + return s.GetToken(MySqlParserEND, 0) +} + +func (s *KeywordsCanBeIdContext) ENDS() antlr.TerminalNode { + return s.GetToken(MySqlParserENDS, 0) +} + +func (s *KeywordsCanBeIdContext) ENGINE() antlr.TerminalNode { + return s.GetToken(MySqlParserENGINE, 0) +} + +func (s *KeywordsCanBeIdContext) ENGINE_ATTRIBUTE() antlr.TerminalNode { + return s.GetToken(MySqlParserENGINE_ATTRIBUTE, 0) +} + +func (s *KeywordsCanBeIdContext) ENGINES() antlr.TerminalNode { + return s.GetToken(MySqlParserENGINES, 0) +} + +func (s *KeywordsCanBeIdContext) ENFORCED() antlr.TerminalNode { + return s.GetToken(MySqlParserENFORCED, 0) +} + +func (s *KeywordsCanBeIdContext) ERROR() antlr.TerminalNode { + return s.GetToken(MySqlParserERROR, 0) +} + +func (s *KeywordsCanBeIdContext) ERRORS() antlr.TerminalNode { + return s.GetToken(MySqlParserERRORS, 0) +} + +func (s *KeywordsCanBeIdContext) ESCAPE() antlr.TerminalNode { + return s.GetToken(MySqlParserESCAPE, 0) +} + +func (s *KeywordsCanBeIdContext) EUR() antlr.TerminalNode { + return s.GetToken(MySqlParserEUR, 0) +} + +func (s *KeywordsCanBeIdContext) EVEN() antlr.TerminalNode { + return s.GetToken(MySqlParserEVEN, 0) +} + +func (s *KeywordsCanBeIdContext) EVENT() antlr.TerminalNode { + return s.GetToken(MySqlParserEVENT, 0) +} + +func (s *KeywordsCanBeIdContext) EVENTS() antlr.TerminalNode { + return s.GetToken(MySqlParserEVENTS, 0) +} + +func (s *KeywordsCanBeIdContext) EVERY() antlr.TerminalNode { + return s.GetToken(MySqlParserEVERY, 0) +} + +func (s *KeywordsCanBeIdContext) EXCEPT() antlr.TerminalNode { + return s.GetToken(MySqlParserEXCEPT, 0) +} + +func (s *KeywordsCanBeIdContext) EXCHANGE() antlr.TerminalNode { + return s.GetToken(MySqlParserEXCHANGE, 0) +} + +func (s *KeywordsCanBeIdContext) EXCLUSIVE() antlr.TerminalNode { + return s.GetToken(MySqlParserEXCLUSIVE, 0) +} + +func (s *KeywordsCanBeIdContext) EXPIRE() antlr.TerminalNode { + return s.GetToken(MySqlParserEXPIRE, 0) +} + +func (s *KeywordsCanBeIdContext) EXPORT() antlr.TerminalNode { + return s.GetToken(MySqlParserEXPORT, 0) +} + +func (s *KeywordsCanBeIdContext) EXTENDED() antlr.TerminalNode { + return s.GetToken(MySqlParserEXTENDED, 0) +} + +func (s *KeywordsCanBeIdContext) EXTENT_SIZE() antlr.TerminalNode { + return s.GetToken(MySqlParserEXTENT_SIZE, 0) +} + +func (s *KeywordsCanBeIdContext) FAILED_LOGIN_ATTEMPTS() antlr.TerminalNode { + return s.GetToken(MySqlParserFAILED_LOGIN_ATTEMPTS, 0) +} + +func (s *KeywordsCanBeIdContext) FAST() antlr.TerminalNode { + return s.GetToken(MySqlParserFAST, 0) +} + +func (s *KeywordsCanBeIdContext) FAULTS() antlr.TerminalNode { + return s.GetToken(MySqlParserFAULTS, 0) +} + +func (s *KeywordsCanBeIdContext) FIELDS() antlr.TerminalNode { + return s.GetToken(MySqlParserFIELDS, 0) +} + +func (s *KeywordsCanBeIdContext) FILE_BLOCK_SIZE() antlr.TerminalNode { + return s.GetToken(MySqlParserFILE_BLOCK_SIZE, 0) +} + +func (s *KeywordsCanBeIdContext) FILTER() antlr.TerminalNode { + return s.GetToken(MySqlParserFILTER, 0) +} + +func (s *KeywordsCanBeIdContext) FIREWALL_ADMIN() antlr.TerminalNode { + return s.GetToken(MySqlParserFIREWALL_ADMIN, 0) +} + +func (s *KeywordsCanBeIdContext) FIREWALL_EXEMPT() antlr.TerminalNode { + return s.GetToken(MySqlParserFIREWALL_EXEMPT, 0) +} + +func (s *KeywordsCanBeIdContext) FIREWALL_USER() antlr.TerminalNode { + return s.GetToken(MySqlParserFIREWALL_USER, 0) +} + +func (s *KeywordsCanBeIdContext) FIRST() antlr.TerminalNode { + return s.GetToken(MySqlParserFIRST, 0) +} + +func (s *KeywordsCanBeIdContext) FIXED() antlr.TerminalNode { + return s.GetToken(MySqlParserFIXED, 0) +} + +func (s *KeywordsCanBeIdContext) FLUSH() antlr.TerminalNode { + return s.GetToken(MySqlParserFLUSH, 0) +} + +func (s *KeywordsCanBeIdContext) FOLLOWS() antlr.TerminalNode { + return s.GetToken(MySqlParserFOLLOWS, 0) +} + +func (s *KeywordsCanBeIdContext) FOUND() antlr.TerminalNode { + return s.GetToken(MySqlParserFOUND, 0) +} + +func (s *KeywordsCanBeIdContext) FULL() antlr.TerminalNode { + return s.GetToken(MySqlParserFULL, 0) +} + +func (s *KeywordsCanBeIdContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(MySqlParserFUNCTION, 0) +} + +func (s *KeywordsCanBeIdContext) GENERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserGENERAL, 0) +} + +func (s *KeywordsCanBeIdContext) GLOBAL() antlr.TerminalNode { + return s.GetToken(MySqlParserGLOBAL, 0) +} + +func (s *KeywordsCanBeIdContext) GRANTS() antlr.TerminalNode { + return s.GetToken(MySqlParserGRANTS, 0) +} + +func (s *KeywordsCanBeIdContext) GROUP() antlr.TerminalNode { + return s.GetToken(MySqlParserGROUP, 0) +} + +func (s *KeywordsCanBeIdContext) GROUP_CONCAT() antlr.TerminalNode { + return s.GetToken(MySqlParserGROUP_CONCAT, 0) +} + +func (s *KeywordsCanBeIdContext) GROUP_REPLICATION() antlr.TerminalNode { + return s.GetToken(MySqlParserGROUP_REPLICATION, 0) +} + +func (s *KeywordsCanBeIdContext) GROUP_REPLICATION_ADMIN() antlr.TerminalNode { + return s.GetToken(MySqlParserGROUP_REPLICATION_ADMIN, 0) +} + +func (s *KeywordsCanBeIdContext) HANDLER() antlr.TerminalNode { + return s.GetToken(MySqlParserHANDLER, 0) +} + +func (s *KeywordsCanBeIdContext) HASH() antlr.TerminalNode { + return s.GetToken(MySqlParserHASH, 0) +} + +func (s *KeywordsCanBeIdContext) HELP() antlr.TerminalNode { + return s.GetToken(MySqlParserHELP, 0) +} + +func (s *KeywordsCanBeIdContext) HISTORY() antlr.TerminalNode { + return s.GetToken(MySqlParserHISTORY, 0) +} + +func (s *KeywordsCanBeIdContext) HOST() antlr.TerminalNode { + return s.GetToken(MySqlParserHOST, 0) +} + +func (s *KeywordsCanBeIdContext) HOSTS() antlr.TerminalNode { + return s.GetToken(MySqlParserHOSTS, 0) +} + +func (s *KeywordsCanBeIdContext) IDENTIFIED() antlr.TerminalNode { + return s.GetToken(MySqlParserIDENTIFIED, 0) +} + +func (s *KeywordsCanBeIdContext) IGNORED() antlr.TerminalNode { + return s.GetToken(MySqlParserIGNORED, 0) +} + +func (s *KeywordsCanBeIdContext) IGNORE_SERVER_IDS() antlr.TerminalNode { + return s.GetToken(MySqlParserIGNORE_SERVER_IDS, 0) +} + +func (s *KeywordsCanBeIdContext) IMPORT() antlr.TerminalNode { + return s.GetToken(MySqlParserIMPORT, 0) +} + +func (s *KeywordsCanBeIdContext) INDEXES() antlr.TerminalNode { + return s.GetToken(MySqlParserINDEXES, 0) +} + +func (s *KeywordsCanBeIdContext) INITIAL_SIZE() antlr.TerminalNode { + return s.GetToken(MySqlParserINITIAL_SIZE, 0) +} + +func (s *KeywordsCanBeIdContext) INNODB_REDO_LOG_ARCHIVE() antlr.TerminalNode { + return s.GetToken(MySqlParserINNODB_REDO_LOG_ARCHIVE, 0) +} + +func (s *KeywordsCanBeIdContext) INPLACE() antlr.TerminalNode { + return s.GetToken(MySqlParserINPLACE, 0) +} + +func (s *KeywordsCanBeIdContext) INSERT_METHOD() antlr.TerminalNode { + return s.GetToken(MySqlParserINSERT_METHOD, 0) +} + +func (s *KeywordsCanBeIdContext) INSTALL() antlr.TerminalNode { + return s.GetToken(MySqlParserINSTALL, 0) +} + +func (s *KeywordsCanBeIdContext) INSTANCE() antlr.TerminalNode { + return s.GetToken(MySqlParserINSTANCE, 0) +} + +func (s *KeywordsCanBeIdContext) INSTANT() antlr.TerminalNode { + return s.GetToken(MySqlParserINSTANT, 0) +} + +func (s *KeywordsCanBeIdContext) INTERNAL() antlr.TerminalNode { + return s.GetToken(MySqlParserINTERNAL, 0) +} + +func (s *KeywordsCanBeIdContext) INVOKE() antlr.TerminalNode { + return s.GetToken(MySqlParserINVOKE, 0) +} + +func (s *KeywordsCanBeIdContext) INVOKER() antlr.TerminalNode { + return s.GetToken(MySqlParserINVOKER, 0) +} + +func (s *KeywordsCanBeIdContext) IO() antlr.TerminalNode { + return s.GetToken(MySqlParserIO, 0) +} + +func (s *KeywordsCanBeIdContext) IO_THREAD() antlr.TerminalNode { + return s.GetToken(MySqlParserIO_THREAD, 0) +} + +func (s *KeywordsCanBeIdContext) IPC() antlr.TerminalNode { + return s.GetToken(MySqlParserIPC, 0) +} + +func (s *KeywordsCanBeIdContext) ISO() antlr.TerminalNode { + return s.GetToken(MySqlParserISO, 0) +} + +func (s *KeywordsCanBeIdContext) ISOLATION() antlr.TerminalNode { + return s.GetToken(MySqlParserISOLATION, 0) +} + +func (s *KeywordsCanBeIdContext) ISSUER() antlr.TerminalNode { + return s.GetToken(MySqlParserISSUER, 0) +} + +func (s *KeywordsCanBeIdContext) JIS() antlr.TerminalNode { + return s.GetToken(MySqlParserJIS, 0) +} + +func (s *KeywordsCanBeIdContext) JSON() antlr.TerminalNode { + return s.GetToken(MySqlParserJSON, 0) +} + +func (s *KeywordsCanBeIdContext) KEY_BLOCK_SIZE() antlr.TerminalNode { + return s.GetToken(MySqlParserKEY_BLOCK_SIZE, 0) +} + +func (s *KeywordsCanBeIdContext) LAMBDA() antlr.TerminalNode { + return s.GetToken(MySqlParserLAMBDA, 0) +} + +func (s *KeywordsCanBeIdContext) LANGUAGE() antlr.TerminalNode { + return s.GetToken(MySqlParserLANGUAGE, 0) +} + +func (s *KeywordsCanBeIdContext) LAST() antlr.TerminalNode { + return s.GetToken(MySqlParserLAST, 0) +} + +func (s *KeywordsCanBeIdContext) LATERAL() antlr.TerminalNode { + return s.GetToken(MySqlParserLATERAL, 0) +} + +func (s *KeywordsCanBeIdContext) LEAVES() antlr.TerminalNode { + return s.GetToken(MySqlParserLEAVES, 0) +} + +func (s *KeywordsCanBeIdContext) LESS() antlr.TerminalNode { + return s.GetToken(MySqlParserLESS, 0) +} + +func (s *KeywordsCanBeIdContext) LEVEL() antlr.TerminalNode { + return s.GetToken(MySqlParserLEVEL, 0) +} + +func (s *KeywordsCanBeIdContext) LIST() antlr.TerminalNode { + return s.GetToken(MySqlParserLIST, 0) +} + +func (s *KeywordsCanBeIdContext) LOCAL() antlr.TerminalNode { + return s.GetToken(MySqlParserLOCAL, 0) +} + +func (s *KeywordsCanBeIdContext) LOGFILE() antlr.TerminalNode { + return s.GetToken(MySqlParserLOGFILE, 0) +} + +func (s *KeywordsCanBeIdContext) LOGS() antlr.TerminalNode { + return s.GetToken(MySqlParserLOGS, 0) +} + +func (s *KeywordsCanBeIdContext) MASTER() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER, 0) +} + +func (s *KeywordsCanBeIdContext) MASTER_AUTO_POSITION() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER_AUTO_POSITION, 0) +} + +func (s *KeywordsCanBeIdContext) MASTER_CONNECT_RETRY() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER_CONNECT_RETRY, 0) +} + +func (s *KeywordsCanBeIdContext) MASTER_DELAY() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER_DELAY, 0) +} + +func (s *KeywordsCanBeIdContext) MASTER_HEARTBEAT_PERIOD() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER_HEARTBEAT_PERIOD, 0) +} + +func (s *KeywordsCanBeIdContext) MASTER_HOST() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER_HOST, 0) +} + +func (s *KeywordsCanBeIdContext) MASTER_LOG_FILE() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER_LOG_FILE, 0) +} + +func (s *KeywordsCanBeIdContext) MASTER_LOG_POS() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER_LOG_POS, 0) +} + +func (s *KeywordsCanBeIdContext) MASTER_PASSWORD() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER_PASSWORD, 0) +} + +func (s *KeywordsCanBeIdContext) MASTER_PORT() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER_PORT, 0) +} + +func (s *KeywordsCanBeIdContext) MASTER_RETRY_COUNT() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER_RETRY_COUNT, 0) +} + +func (s *KeywordsCanBeIdContext) MASTER_SSL() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER_SSL, 0) +} + +func (s *KeywordsCanBeIdContext) MASTER_SSL_CA() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER_SSL_CA, 0) +} + +func (s *KeywordsCanBeIdContext) MASTER_SSL_CAPATH() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER_SSL_CAPATH, 0) +} + +func (s *KeywordsCanBeIdContext) MASTER_SSL_CERT() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER_SSL_CERT, 0) +} + +func (s *KeywordsCanBeIdContext) MASTER_SSL_CIPHER() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER_SSL_CIPHER, 0) +} + +func (s *KeywordsCanBeIdContext) MASTER_SSL_CRL() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER_SSL_CRL, 0) +} + +func (s *KeywordsCanBeIdContext) MASTER_SSL_CRLPATH() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER_SSL_CRLPATH, 0) +} + +func (s *KeywordsCanBeIdContext) MASTER_SSL_KEY() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER_SSL_KEY, 0) +} + +func (s *KeywordsCanBeIdContext) MASTER_TLS_VERSION() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER_TLS_VERSION, 0) +} + +func (s *KeywordsCanBeIdContext) MASTER_USER() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER_USER, 0) +} + +func (s *KeywordsCanBeIdContext) MAX_CONNECTIONS_PER_HOUR() antlr.TerminalNode { + return s.GetToken(MySqlParserMAX_CONNECTIONS_PER_HOUR, 0) +} + +func (s *KeywordsCanBeIdContext) MAX_QUERIES_PER_HOUR() antlr.TerminalNode { + return s.GetToken(MySqlParserMAX_QUERIES_PER_HOUR, 0) +} + +func (s *KeywordsCanBeIdContext) MAX() antlr.TerminalNode { + return s.GetToken(MySqlParserMAX, 0) +} + +func (s *KeywordsCanBeIdContext) MAX_ROWS() antlr.TerminalNode { + return s.GetToken(MySqlParserMAX_ROWS, 0) +} + +func (s *KeywordsCanBeIdContext) MAX_SIZE() antlr.TerminalNode { + return s.GetToken(MySqlParserMAX_SIZE, 0) +} + +func (s *KeywordsCanBeIdContext) MAX_UPDATES_PER_HOUR() antlr.TerminalNode { + return s.GetToken(MySqlParserMAX_UPDATES_PER_HOUR, 0) +} + +func (s *KeywordsCanBeIdContext) MAX_USER_CONNECTIONS() antlr.TerminalNode { + return s.GetToken(MySqlParserMAX_USER_CONNECTIONS, 0) +} + +func (s *KeywordsCanBeIdContext) MEDIUM() antlr.TerminalNode { + return s.GetToken(MySqlParserMEDIUM, 0) +} + +func (s *KeywordsCanBeIdContext) MEMBER() antlr.TerminalNode { + return s.GetToken(MySqlParserMEMBER, 0) +} + +func (s *KeywordsCanBeIdContext) MEMORY() antlr.TerminalNode { + return s.GetToken(MySqlParserMEMORY, 0) +} + +func (s *KeywordsCanBeIdContext) MERGE() antlr.TerminalNode { + return s.GetToken(MySqlParserMERGE, 0) +} + +func (s *KeywordsCanBeIdContext) MESSAGE_TEXT() antlr.TerminalNode { + return s.GetToken(MySqlParserMESSAGE_TEXT, 0) +} + +func (s *KeywordsCanBeIdContext) MID() antlr.TerminalNode { + return s.GetToken(MySqlParserMID, 0) +} + +func (s *KeywordsCanBeIdContext) MIGRATE() antlr.TerminalNode { + return s.GetToken(MySqlParserMIGRATE, 0) +} + +func (s *KeywordsCanBeIdContext) MIN() antlr.TerminalNode { + return s.GetToken(MySqlParserMIN, 0) +} + +func (s *KeywordsCanBeIdContext) MIN_ROWS() antlr.TerminalNode { + return s.GetToken(MySqlParserMIN_ROWS, 0) +} + +func (s *KeywordsCanBeIdContext) MODE() antlr.TerminalNode { + return s.GetToken(MySqlParserMODE, 0) +} + +func (s *KeywordsCanBeIdContext) MODIFY() antlr.TerminalNode { + return s.GetToken(MySqlParserMODIFY, 0) +} + +func (s *KeywordsCanBeIdContext) MUTEX() antlr.TerminalNode { + return s.GetToken(MySqlParserMUTEX, 0) +} + +func (s *KeywordsCanBeIdContext) MYSQL() antlr.TerminalNode { + return s.GetToken(MySqlParserMYSQL, 0) +} + +func (s *KeywordsCanBeIdContext) MYSQL_ERRNO() antlr.TerminalNode { + return s.GetToken(MySqlParserMYSQL_ERRNO, 0) +} + +func (s *KeywordsCanBeIdContext) NAME() antlr.TerminalNode { + return s.GetToken(MySqlParserNAME, 0) +} + +func (s *KeywordsCanBeIdContext) NAMES() antlr.TerminalNode { + return s.GetToken(MySqlParserNAMES, 0) +} + +func (s *KeywordsCanBeIdContext) NCHAR() antlr.TerminalNode { + return s.GetToken(MySqlParserNCHAR, 0) +} + +func (s *KeywordsCanBeIdContext) NDB_STORED_USER() antlr.TerminalNode { + return s.GetToken(MySqlParserNDB_STORED_USER, 0) +} + +func (s *KeywordsCanBeIdContext) NESTED() antlr.TerminalNode { + return s.GetToken(MySqlParserNESTED, 0) +} + +func (s *KeywordsCanBeIdContext) NEVER() antlr.TerminalNode { + return s.GetToken(MySqlParserNEVER, 0) +} + +func (s *KeywordsCanBeIdContext) NEXT() antlr.TerminalNode { + return s.GetToken(MySqlParserNEXT, 0) +} + +func (s *KeywordsCanBeIdContext) NO() antlr.TerminalNode { + return s.GetToken(MySqlParserNO, 0) +} + +func (s *KeywordsCanBeIdContext) NOCOPY() antlr.TerminalNode { + return s.GetToken(MySqlParserNOCOPY, 0) +} + +func (s *KeywordsCanBeIdContext) NODEGROUP() antlr.TerminalNode { + return s.GetToken(MySqlParserNODEGROUP, 0) +} + +func (s *KeywordsCanBeIdContext) NONE() antlr.TerminalNode { + return s.GetToken(MySqlParserNONE, 0) +} + +func (s *KeywordsCanBeIdContext) NOWAIT() antlr.TerminalNode { + return s.GetToken(MySqlParserNOWAIT, 0) +} + +func (s *KeywordsCanBeIdContext) NUMBER() antlr.TerminalNode { + return s.GetToken(MySqlParserNUMBER, 0) +} + +func (s *KeywordsCanBeIdContext) ODBC() antlr.TerminalNode { + return s.GetToken(MySqlParserODBC, 0) +} + +func (s *KeywordsCanBeIdContext) OFFLINE() antlr.TerminalNode { + return s.GetToken(MySqlParserOFFLINE, 0) +} + +func (s *KeywordsCanBeIdContext) OFFSET() antlr.TerminalNode { + return s.GetToken(MySqlParserOFFSET, 0) +} + +func (s *KeywordsCanBeIdContext) OF() antlr.TerminalNode { + return s.GetToken(MySqlParserOF, 0) +} + +func (s *KeywordsCanBeIdContext) OJ() antlr.TerminalNode { + return s.GetToken(MySqlParserOJ, 0) +} + +func (s *KeywordsCanBeIdContext) OLD_PASSWORD() antlr.TerminalNode { + return s.GetToken(MySqlParserOLD_PASSWORD, 0) +} + +func (s *KeywordsCanBeIdContext) ONE() antlr.TerminalNode { + return s.GetToken(MySqlParserONE, 0) +} + +func (s *KeywordsCanBeIdContext) ONLINE() antlr.TerminalNode { + return s.GetToken(MySqlParserONLINE, 0) +} + +func (s *KeywordsCanBeIdContext) ONLY() antlr.TerminalNode { + return s.GetToken(MySqlParserONLY, 0) +} + +func (s *KeywordsCanBeIdContext) OPEN() antlr.TerminalNode { + return s.GetToken(MySqlParserOPEN, 0) +} + +func (s *KeywordsCanBeIdContext) OPTIMIZER_COSTS() antlr.TerminalNode { + return s.GetToken(MySqlParserOPTIMIZER_COSTS, 0) +} + +func (s *KeywordsCanBeIdContext) OPTIONAL() antlr.TerminalNode { + return s.GetToken(MySqlParserOPTIONAL, 0) +} + +func (s *KeywordsCanBeIdContext) OPTIONS() antlr.TerminalNode { + return s.GetToken(MySqlParserOPTIONS, 0) +} + +func (s *KeywordsCanBeIdContext) ORDER() antlr.TerminalNode { + return s.GetToken(MySqlParserORDER, 0) +} + +func (s *KeywordsCanBeIdContext) ORDINALITY() antlr.TerminalNode { + return s.GetToken(MySqlParserORDINALITY, 0) +} + +func (s *KeywordsCanBeIdContext) OWNER() antlr.TerminalNode { + return s.GetToken(MySqlParserOWNER, 0) +} + +func (s *KeywordsCanBeIdContext) PACK_KEYS() antlr.TerminalNode { + return s.GetToken(MySqlParserPACK_KEYS, 0) +} + +func (s *KeywordsCanBeIdContext) PAGE() antlr.TerminalNode { + return s.GetToken(MySqlParserPAGE, 0) +} + +func (s *KeywordsCanBeIdContext) PARSER() antlr.TerminalNode { + return s.GetToken(MySqlParserPARSER, 0) +} + +func (s *KeywordsCanBeIdContext) PARTIAL() antlr.TerminalNode { + return s.GetToken(MySqlParserPARTIAL, 0) +} + +func (s *KeywordsCanBeIdContext) PARTITIONING() antlr.TerminalNode { + return s.GetToken(MySqlParserPARTITIONING, 0) +} + +func (s *KeywordsCanBeIdContext) PARTITIONS() antlr.TerminalNode { + return s.GetToken(MySqlParserPARTITIONS, 0) +} + +func (s *KeywordsCanBeIdContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(MySqlParserPASSWORD, 0) +} + +func (s *KeywordsCanBeIdContext) PASSWORDLESS_USER_ADMIN() antlr.TerminalNode { + return s.GetToken(MySqlParserPASSWORDLESS_USER_ADMIN, 0) +} + +func (s *KeywordsCanBeIdContext) PASSWORD_LOCK_TIME() antlr.TerminalNode { + return s.GetToken(MySqlParserPASSWORD_LOCK_TIME, 0) +} + +func (s *KeywordsCanBeIdContext) PATH() antlr.TerminalNode { + return s.GetToken(MySqlParserPATH, 0) +} + +func (s *KeywordsCanBeIdContext) PERSIST_RO_VARIABLES_ADMIN() antlr.TerminalNode { + return s.GetToken(MySqlParserPERSIST_RO_VARIABLES_ADMIN, 0) +} + +func (s *KeywordsCanBeIdContext) PHASE() antlr.TerminalNode { + return s.GetToken(MySqlParserPHASE, 0) +} + +func (s *KeywordsCanBeIdContext) PLUGINS() antlr.TerminalNode { + return s.GetToken(MySqlParserPLUGINS, 0) +} + +func (s *KeywordsCanBeIdContext) PLUGIN_DIR() antlr.TerminalNode { + return s.GetToken(MySqlParserPLUGIN_DIR, 0) +} + +func (s *KeywordsCanBeIdContext) PLUGIN() antlr.TerminalNode { + return s.GetToken(MySqlParserPLUGIN, 0) +} + +func (s *KeywordsCanBeIdContext) PORT() antlr.TerminalNode { + return s.GetToken(MySqlParserPORT, 0) +} + +func (s *KeywordsCanBeIdContext) PRECEDES() antlr.TerminalNode { + return s.GetToken(MySqlParserPRECEDES, 0) +} + +func (s *KeywordsCanBeIdContext) PREPARE() antlr.TerminalNode { + return s.GetToken(MySqlParserPREPARE, 0) +} + +func (s *KeywordsCanBeIdContext) PRESERVE() antlr.TerminalNode { + return s.GetToken(MySqlParserPRESERVE, 0) +} + +func (s *KeywordsCanBeIdContext) PREV() antlr.TerminalNode { + return s.GetToken(MySqlParserPREV, 0) +} + +func (s *KeywordsCanBeIdContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(MySqlParserPRIMARY, 0) +} + +func (s *KeywordsCanBeIdContext) PROCESSLIST() antlr.TerminalNode { + return s.GetToken(MySqlParserPROCESSLIST, 0) +} + +func (s *KeywordsCanBeIdContext) PROFILE() antlr.TerminalNode { + return s.GetToken(MySqlParserPROFILE, 0) +} + +func (s *KeywordsCanBeIdContext) PROFILES() antlr.TerminalNode { + return s.GetToken(MySqlParserPROFILES, 0) +} + +func (s *KeywordsCanBeIdContext) PROXY() antlr.TerminalNode { + return s.GetToken(MySqlParserPROXY, 0) +} + +func (s *KeywordsCanBeIdContext) QUERY() antlr.TerminalNode { + return s.GetToken(MySqlParserQUERY, 0) +} + +func (s *KeywordsCanBeIdContext) QUICK() antlr.TerminalNode { + return s.GetToken(MySqlParserQUICK, 0) +} + +func (s *KeywordsCanBeIdContext) REBUILD() antlr.TerminalNode { + return s.GetToken(MySqlParserREBUILD, 0) +} + +func (s *KeywordsCanBeIdContext) RECOVER() antlr.TerminalNode { + return s.GetToken(MySqlParserRECOVER, 0) +} + +func (s *KeywordsCanBeIdContext) RECURSIVE() antlr.TerminalNode { + return s.GetToken(MySqlParserRECURSIVE, 0) +} + +func (s *KeywordsCanBeIdContext) REDO_BUFFER_SIZE() antlr.TerminalNode { + return s.GetToken(MySqlParserREDO_BUFFER_SIZE, 0) +} + +func (s *KeywordsCanBeIdContext) REDUNDANT() antlr.TerminalNode { + return s.GetToken(MySqlParserREDUNDANT, 0) +} + +func (s *KeywordsCanBeIdContext) RELAY() antlr.TerminalNode { + return s.GetToken(MySqlParserRELAY, 0) +} + +func (s *KeywordsCanBeIdContext) RELAYLOG() antlr.TerminalNode { + return s.GetToken(MySqlParserRELAYLOG, 0) +} + +func (s *KeywordsCanBeIdContext) RELAY_LOG_FILE() antlr.TerminalNode { + return s.GetToken(MySqlParserRELAY_LOG_FILE, 0) +} + +func (s *KeywordsCanBeIdContext) RELAY_LOG_POS() antlr.TerminalNode { + return s.GetToken(MySqlParserRELAY_LOG_POS, 0) +} + +func (s *KeywordsCanBeIdContext) REMOVE() antlr.TerminalNode { + return s.GetToken(MySqlParserREMOVE, 0) +} + +func (s *KeywordsCanBeIdContext) REORGANIZE() antlr.TerminalNode { + return s.GetToken(MySqlParserREORGANIZE, 0) +} + +func (s *KeywordsCanBeIdContext) REPAIR() antlr.TerminalNode { + return s.GetToken(MySqlParserREPAIR, 0) +} + +func (s *KeywordsCanBeIdContext) REPLICATE_DO_DB() antlr.TerminalNode { + return s.GetToken(MySqlParserREPLICATE_DO_DB, 0) +} + +func (s *KeywordsCanBeIdContext) REPLICATE_DO_TABLE() antlr.TerminalNode { + return s.GetToken(MySqlParserREPLICATE_DO_TABLE, 0) +} + +func (s *KeywordsCanBeIdContext) REPLICATE_IGNORE_DB() antlr.TerminalNode { + return s.GetToken(MySqlParserREPLICATE_IGNORE_DB, 0) +} + +func (s *KeywordsCanBeIdContext) REPLICATE_IGNORE_TABLE() antlr.TerminalNode { + return s.GetToken(MySqlParserREPLICATE_IGNORE_TABLE, 0) +} + +func (s *KeywordsCanBeIdContext) REPLICATE_REWRITE_DB() antlr.TerminalNode { + return s.GetToken(MySqlParserREPLICATE_REWRITE_DB, 0) +} + +func (s *KeywordsCanBeIdContext) REPLICATE_WILD_DO_TABLE() antlr.TerminalNode { + return s.GetToken(MySqlParserREPLICATE_WILD_DO_TABLE, 0) +} + +func (s *KeywordsCanBeIdContext) REPLICATE_WILD_IGNORE_TABLE() antlr.TerminalNode { + return s.GetToken(MySqlParserREPLICATE_WILD_IGNORE_TABLE, 0) +} + +func (s *KeywordsCanBeIdContext) REPLICATION() antlr.TerminalNode { + return s.GetToken(MySqlParserREPLICATION, 0) +} + +func (s *KeywordsCanBeIdContext) REPLICATION_APPLIER() antlr.TerminalNode { + return s.GetToken(MySqlParserREPLICATION_APPLIER, 0) +} + +func (s *KeywordsCanBeIdContext) REPLICATION_SLAVE_ADMIN() antlr.TerminalNode { + return s.GetToken(MySqlParserREPLICATION_SLAVE_ADMIN, 0) +} + +func (s *KeywordsCanBeIdContext) RESET() antlr.TerminalNode { + return s.GetToken(MySqlParserRESET, 0) +} + +func (s *KeywordsCanBeIdContext) RESOURCE_GROUP_ADMIN() antlr.TerminalNode { + return s.GetToken(MySqlParserRESOURCE_GROUP_ADMIN, 0) +} + +func (s *KeywordsCanBeIdContext) RESOURCE_GROUP_USER() antlr.TerminalNode { + return s.GetToken(MySqlParserRESOURCE_GROUP_USER, 0) +} + +func (s *KeywordsCanBeIdContext) RESUME() antlr.TerminalNode { + return s.GetToken(MySqlParserRESUME, 0) +} + +func (s *KeywordsCanBeIdContext) RETURNED_SQLSTATE() antlr.TerminalNode { + return s.GetToken(MySqlParserRETURNED_SQLSTATE, 0) +} + +func (s *KeywordsCanBeIdContext) RETURNING() antlr.TerminalNode { + return s.GetToken(MySqlParserRETURNING, 0) +} + +func (s *KeywordsCanBeIdContext) RETURNS() antlr.TerminalNode { + return s.GetToken(MySqlParserRETURNS, 0) +} + +func (s *KeywordsCanBeIdContext) REUSE() antlr.TerminalNode { + return s.GetToken(MySqlParserREUSE, 0) +} + +func (s *KeywordsCanBeIdContext) ROLE() antlr.TerminalNode { + return s.GetToken(MySqlParserROLE, 0) +} + +func (s *KeywordsCanBeIdContext) ROLE_ADMIN() antlr.TerminalNode { + return s.GetToken(MySqlParserROLE_ADMIN, 0) +} + +func (s *KeywordsCanBeIdContext) ROLLBACK() antlr.TerminalNode { + return s.GetToken(MySqlParserROLLBACK, 0) +} + +func (s *KeywordsCanBeIdContext) ROLLUP() antlr.TerminalNode { + return s.GetToken(MySqlParserROLLUP, 0) +} + +func (s *KeywordsCanBeIdContext) ROTATE() antlr.TerminalNode { + return s.GetToken(MySqlParserROTATE, 0) +} + +func (s *KeywordsCanBeIdContext) ROW() antlr.TerminalNode { + return s.GetToken(MySqlParserROW, 0) +} + +func (s *KeywordsCanBeIdContext) ROWS() antlr.TerminalNode { + return s.GetToken(MySqlParserROWS, 0) +} + +func (s *KeywordsCanBeIdContext) ROW_FORMAT() antlr.TerminalNode { + return s.GetToken(MySqlParserROW_FORMAT, 0) +} + +func (s *KeywordsCanBeIdContext) RTREE() antlr.TerminalNode { + return s.GetToken(MySqlParserRTREE, 0) +} + +func (s *KeywordsCanBeIdContext) S3() antlr.TerminalNode { + return s.GetToken(MySqlParserS3, 0) +} + +func (s *KeywordsCanBeIdContext) SAVEPOINT() antlr.TerminalNode { + return s.GetToken(MySqlParserSAVEPOINT, 0) +} + +func (s *KeywordsCanBeIdContext) SCHEDULE() antlr.TerminalNode { + return s.GetToken(MySqlParserSCHEDULE, 0) +} + +func (s *KeywordsCanBeIdContext) SCHEMA_NAME() antlr.TerminalNode { + return s.GetToken(MySqlParserSCHEMA_NAME, 0) +} + +func (s *KeywordsCanBeIdContext) SECURITY() antlr.TerminalNode { + return s.GetToken(MySqlParserSECURITY, 0) +} + +func (s *KeywordsCanBeIdContext) SECONDARY_ENGINE_ATTRIBUTE() antlr.TerminalNode { + return s.GetToken(MySqlParserSECONDARY_ENGINE_ATTRIBUTE, 0) +} + +func (s *KeywordsCanBeIdContext) SERIAL() antlr.TerminalNode { + return s.GetToken(MySqlParserSERIAL, 0) +} + +func (s *KeywordsCanBeIdContext) SERVER() antlr.TerminalNode { + return s.GetToken(MySqlParserSERVER, 0) +} + +func (s *KeywordsCanBeIdContext) SESSION() antlr.TerminalNode { + return s.GetToken(MySqlParserSESSION, 0) +} + +func (s *KeywordsCanBeIdContext) SESSION_VARIABLES_ADMIN() antlr.TerminalNode { + return s.GetToken(MySqlParserSESSION_VARIABLES_ADMIN, 0) +} + +func (s *KeywordsCanBeIdContext) SET_USER_ID() antlr.TerminalNode { + return s.GetToken(MySqlParserSET_USER_ID, 0) +} + +func (s *KeywordsCanBeIdContext) SHARE() antlr.TerminalNode { + return s.GetToken(MySqlParserSHARE, 0) +} + +func (s *KeywordsCanBeIdContext) SHARED() antlr.TerminalNode { + return s.GetToken(MySqlParserSHARED, 0) +} + +func (s *KeywordsCanBeIdContext) SHOW_ROUTINE() antlr.TerminalNode { + return s.GetToken(MySqlParserSHOW_ROUTINE, 0) +} + +func (s *KeywordsCanBeIdContext) SIGNED() antlr.TerminalNode { + return s.GetToken(MySqlParserSIGNED, 0) +} + +func (s *KeywordsCanBeIdContext) SIMPLE() antlr.TerminalNode { + return s.GetToken(MySqlParserSIMPLE, 0) +} + +func (s *KeywordsCanBeIdContext) SLAVE() antlr.TerminalNode { + return s.GetToken(MySqlParserSLAVE, 0) +} + +func (s *KeywordsCanBeIdContext) SLOW() antlr.TerminalNode { + return s.GetToken(MySqlParserSLOW, 0) +} + +func (s *KeywordsCanBeIdContext) SKIP_QUERY_REWRITE() antlr.TerminalNode { + return s.GetToken(MySqlParserSKIP_QUERY_REWRITE, 0) +} + +func (s *KeywordsCanBeIdContext) SNAPSHOT() antlr.TerminalNode { + return s.GetToken(MySqlParserSNAPSHOT, 0) +} + +func (s *KeywordsCanBeIdContext) SOCKET() antlr.TerminalNode { + return s.GetToken(MySqlParserSOCKET, 0) +} + +func (s *KeywordsCanBeIdContext) SOME() antlr.TerminalNode { + return s.GetToken(MySqlParserSOME, 0) +} + +func (s *KeywordsCanBeIdContext) SONAME() antlr.TerminalNode { + return s.GetToken(MySqlParserSONAME, 0) +} + +func (s *KeywordsCanBeIdContext) SOUNDS() antlr.TerminalNode { + return s.GetToken(MySqlParserSOUNDS, 0) +} + +func (s *KeywordsCanBeIdContext) SOURCE() antlr.TerminalNode { + return s.GetToken(MySqlParserSOURCE, 0) +} + +func (s *KeywordsCanBeIdContext) SQL_AFTER_GTIDS() antlr.TerminalNode { + return s.GetToken(MySqlParserSQL_AFTER_GTIDS, 0) +} + +func (s *KeywordsCanBeIdContext) SQL_AFTER_MTS_GAPS() antlr.TerminalNode { + return s.GetToken(MySqlParserSQL_AFTER_MTS_GAPS, 0) +} + +func (s *KeywordsCanBeIdContext) SQL_BEFORE_GTIDS() antlr.TerminalNode { + return s.GetToken(MySqlParserSQL_BEFORE_GTIDS, 0) +} + +func (s *KeywordsCanBeIdContext) SQL_BUFFER_RESULT() antlr.TerminalNode { + return s.GetToken(MySqlParserSQL_BUFFER_RESULT, 0) +} + +func (s *KeywordsCanBeIdContext) SQL_CACHE() antlr.TerminalNode { + return s.GetToken(MySqlParserSQL_CACHE, 0) +} + +func (s *KeywordsCanBeIdContext) SQL_NO_CACHE() antlr.TerminalNode { + return s.GetToken(MySqlParserSQL_NO_CACHE, 0) +} + +func (s *KeywordsCanBeIdContext) SQL_THREAD() antlr.TerminalNode { + return s.GetToken(MySqlParserSQL_THREAD, 0) +} + +func (s *KeywordsCanBeIdContext) STACKED() antlr.TerminalNode { + return s.GetToken(MySqlParserSTACKED, 0) +} + +func (s *KeywordsCanBeIdContext) START() antlr.TerminalNode { + return s.GetToken(MySqlParserSTART, 0) +} + +func (s *KeywordsCanBeIdContext) STARTS() antlr.TerminalNode { + return s.GetToken(MySqlParserSTARTS, 0) +} + +func (s *KeywordsCanBeIdContext) STATS_AUTO_RECALC() antlr.TerminalNode { + return s.GetToken(MySqlParserSTATS_AUTO_RECALC, 0) +} + +func (s *KeywordsCanBeIdContext) STATS_PERSISTENT() antlr.TerminalNode { + return s.GetToken(MySqlParserSTATS_PERSISTENT, 0) +} + +func (s *KeywordsCanBeIdContext) STATS_SAMPLE_PAGES() antlr.TerminalNode { + return s.GetToken(MySqlParserSTATS_SAMPLE_PAGES, 0) +} + +func (s *KeywordsCanBeIdContext) STATUS() antlr.TerminalNode { + return s.GetToken(MySqlParserSTATUS, 0) +} + +func (s *KeywordsCanBeIdContext) STD() antlr.TerminalNode { + return s.GetToken(MySqlParserSTD, 0) +} + +func (s *KeywordsCanBeIdContext) STDDEV() antlr.TerminalNode { + return s.GetToken(MySqlParserSTDDEV, 0) +} + +func (s *KeywordsCanBeIdContext) STDDEV_POP() antlr.TerminalNode { + return s.GetToken(MySqlParserSTDDEV_POP, 0) +} + +func (s *KeywordsCanBeIdContext) STDDEV_SAMP() antlr.TerminalNode { + return s.GetToken(MySqlParserSTDDEV_SAMP, 0) +} + +func (s *KeywordsCanBeIdContext) STOP() antlr.TerminalNode { + return s.GetToken(MySqlParserSTOP, 0) +} + +func (s *KeywordsCanBeIdContext) STORAGE() antlr.TerminalNode { + return s.GetToken(MySqlParserSTORAGE, 0) +} + +func (s *KeywordsCanBeIdContext) STRING() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING, 0) +} + +func (s *KeywordsCanBeIdContext) SUBCLASS_ORIGIN() antlr.TerminalNode { + return s.GetToken(MySqlParserSUBCLASS_ORIGIN, 0) +} + +func (s *KeywordsCanBeIdContext) SUBJECT() antlr.TerminalNode { + return s.GetToken(MySqlParserSUBJECT, 0) +} + +func (s *KeywordsCanBeIdContext) SUBPARTITION() antlr.TerminalNode { + return s.GetToken(MySqlParserSUBPARTITION, 0) +} + +func (s *KeywordsCanBeIdContext) SUBPARTITIONS() antlr.TerminalNode { + return s.GetToken(MySqlParserSUBPARTITIONS, 0) +} + +func (s *KeywordsCanBeIdContext) SUM() antlr.TerminalNode { + return s.GetToken(MySqlParserSUM, 0) +} + +func (s *KeywordsCanBeIdContext) SUSPEND() antlr.TerminalNode { + return s.GetToken(MySqlParserSUSPEND, 0) +} + +func (s *KeywordsCanBeIdContext) SWAPS() antlr.TerminalNode { + return s.GetToken(MySqlParserSWAPS, 0) +} + +func (s *KeywordsCanBeIdContext) SWITCHES() antlr.TerminalNode { + return s.GetToken(MySqlParserSWITCHES, 0) +} + +func (s *KeywordsCanBeIdContext) SYSTEM_VARIABLES_ADMIN() antlr.TerminalNode { + return s.GetToken(MySqlParserSYSTEM_VARIABLES_ADMIN, 0) +} + +func (s *KeywordsCanBeIdContext) TABLE_NAME() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLE_NAME, 0) +} + +func (s *KeywordsCanBeIdContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLESPACE, 0) +} + +func (s *KeywordsCanBeIdContext) TABLE_ENCRYPTION_ADMIN() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLE_ENCRYPTION_ADMIN, 0) +} + +func (s *KeywordsCanBeIdContext) TABLE_TYPE() antlr.TerminalNode { + return s.GetToken(MySqlParserTABLE_TYPE, 0) +} + +func (s *KeywordsCanBeIdContext) TEMPORARY() antlr.TerminalNode { + return s.GetToken(MySqlParserTEMPORARY, 0) +} + +func (s *KeywordsCanBeIdContext) TEMPTABLE() antlr.TerminalNode { + return s.GetToken(MySqlParserTEMPTABLE, 0) +} + +func (s *KeywordsCanBeIdContext) THAN() antlr.TerminalNode { + return s.GetToken(MySqlParserTHAN, 0) +} + +func (s *KeywordsCanBeIdContext) TP_CONNECTION_ADMIN() antlr.TerminalNode { + return s.GetToken(MySqlParserTP_CONNECTION_ADMIN, 0) +} + +func (s *KeywordsCanBeIdContext) TRADITIONAL() antlr.TerminalNode { + return s.GetToken(MySqlParserTRADITIONAL, 0) +} + +func (s *KeywordsCanBeIdContext) TRANSACTION() antlr.TerminalNode { + return s.GetToken(MySqlParserTRANSACTION, 0) +} + +func (s *KeywordsCanBeIdContext) TRANSACTIONAL() antlr.TerminalNode { + return s.GetToken(MySqlParserTRANSACTIONAL, 0) +} + +func (s *KeywordsCanBeIdContext) TRIGGERS() antlr.TerminalNode { + return s.GetToken(MySqlParserTRIGGERS, 0) +} + +func (s *KeywordsCanBeIdContext) TRUNCATE() antlr.TerminalNode { + return s.GetToken(MySqlParserTRUNCATE, 0) +} + +func (s *KeywordsCanBeIdContext) UNBOUNDED() antlr.TerminalNode { + return s.GetToken(MySqlParserUNBOUNDED, 0) +} + +func (s *KeywordsCanBeIdContext) UNDEFINED() antlr.TerminalNode { + return s.GetToken(MySqlParserUNDEFINED, 0) +} + +func (s *KeywordsCanBeIdContext) UNDOFILE() antlr.TerminalNode { + return s.GetToken(MySqlParserUNDOFILE, 0) +} + +func (s *KeywordsCanBeIdContext) UNDO_BUFFER_SIZE() antlr.TerminalNode { + return s.GetToken(MySqlParserUNDO_BUFFER_SIZE, 0) +} + +func (s *KeywordsCanBeIdContext) UNINSTALL() antlr.TerminalNode { + return s.GetToken(MySqlParserUNINSTALL, 0) +} + +func (s *KeywordsCanBeIdContext) UNKNOWN() antlr.TerminalNode { + return s.GetToken(MySqlParserUNKNOWN, 0) +} + +func (s *KeywordsCanBeIdContext) UNTIL() antlr.TerminalNode { + return s.GetToken(MySqlParserUNTIL, 0) +} + +func (s *KeywordsCanBeIdContext) UPGRADE() antlr.TerminalNode { + return s.GetToken(MySqlParserUPGRADE, 0) +} + +func (s *KeywordsCanBeIdContext) USA() antlr.TerminalNode { + return s.GetToken(MySqlParserUSA, 0) +} + +func (s *KeywordsCanBeIdContext) USER() antlr.TerminalNode { + return s.GetToken(MySqlParserUSER, 0) +} + +func (s *KeywordsCanBeIdContext) USE_FRM() antlr.TerminalNode { + return s.GetToken(MySqlParserUSE_FRM, 0) +} + +func (s *KeywordsCanBeIdContext) USER_RESOURCES() antlr.TerminalNode { + return s.GetToken(MySqlParserUSER_RESOURCES, 0) +} + +func (s *KeywordsCanBeIdContext) VALIDATION() antlr.TerminalNode { + return s.GetToken(MySqlParserVALIDATION, 0) +} + +func (s *KeywordsCanBeIdContext) VALUE() antlr.TerminalNode { + return s.GetToken(MySqlParserVALUE, 0) +} + +func (s *KeywordsCanBeIdContext) VAR_POP() antlr.TerminalNode { + return s.GetToken(MySqlParserVAR_POP, 0) +} + +func (s *KeywordsCanBeIdContext) VAR_SAMP() antlr.TerminalNode { + return s.GetToken(MySqlParserVAR_SAMP, 0) +} + +func (s *KeywordsCanBeIdContext) VARIABLES() antlr.TerminalNode { + return s.GetToken(MySqlParserVARIABLES, 0) +} + +func (s *KeywordsCanBeIdContext) VARIANCE() antlr.TerminalNode { + return s.GetToken(MySqlParserVARIANCE, 0) +} + +func (s *KeywordsCanBeIdContext) VERSION_TOKEN_ADMIN() antlr.TerminalNode { + return s.GetToken(MySqlParserVERSION_TOKEN_ADMIN, 0) +} + +func (s *KeywordsCanBeIdContext) VIEW() antlr.TerminalNode { + return s.GetToken(MySqlParserVIEW, 0) +} + +func (s *KeywordsCanBeIdContext) VIRTUAL() antlr.TerminalNode { + return s.GetToken(MySqlParserVIRTUAL, 0) +} + +func (s *KeywordsCanBeIdContext) WAIT() antlr.TerminalNode { + return s.GetToken(MySqlParserWAIT, 0) +} + +func (s *KeywordsCanBeIdContext) WARNINGS() antlr.TerminalNode { + return s.GetToken(MySqlParserWARNINGS, 0) +} + +func (s *KeywordsCanBeIdContext) WITHOUT() antlr.TerminalNode { + return s.GetToken(MySqlParserWITHOUT, 0) +} + +func (s *KeywordsCanBeIdContext) WORK() antlr.TerminalNode { + return s.GetToken(MySqlParserWORK, 0) +} + +func (s *KeywordsCanBeIdContext) WRAPPER() antlr.TerminalNode { + return s.GetToken(MySqlParserWRAPPER, 0) +} + +func (s *KeywordsCanBeIdContext) X509() antlr.TerminalNode { + return s.GetToken(MySqlParserX509, 0) +} + +func (s *KeywordsCanBeIdContext) XA() antlr.TerminalNode { + return s.GetToken(MySqlParserXA, 0) +} + +func (s *KeywordsCanBeIdContext) XA_RECOVER_ADMIN() antlr.TerminalNode { + return s.GetToken(MySqlParserXA_RECOVER_ADMIN, 0) +} + +func (s *KeywordsCanBeIdContext) XML() antlr.TerminalNode { + return s.GetToken(MySqlParserXML, 0) +} + +func (s *KeywordsCanBeIdContext) YES() antlr.TerminalNode { + return s.GetToken(MySqlParserYES, 0) +} + +func (s *KeywordsCanBeIdContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KeywordsCanBeIdContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KeywordsCanBeIdContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterKeywordsCanBeId(s) + } +} + +func (s *KeywordsCanBeIdContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitKeywordsCanBeId(s) + } +} + +func (p *MySqlParser) KeywordsCanBeId() (localctx IKeywordsCanBeIdContext) { + localctx = NewKeywordsCanBeIdContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 718, MySqlParserRULE_keywordsCanBeId) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7473) + _la = p.GetTokenStream().LA(1) + + if !(((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&756890782757308416) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&146666055054393409) != 0) || _la == MySqlParserSKIP_QUERY_REWRITE || _la == MySqlParserSTACKED || ((int64((_la-239)) & ^0x3f) == 0 && ((int64(1)<<(_la-239))&3539794122741121025) != 0) || ((int64((_la-306)) & ^0x3f) == 0 && ((int64(1)<<(_la-306))&-134217473) != 0) || ((int64((_la-370)) & ^0x3f) == 0 && ((int64(1)<<(_la-370))&-171798822913) != 0) || ((int64((_la-435)) & ^0x3f) == 0 && ((int64(1)<<(_la-435))&-33685505) != 0) || ((int64((_la-499)) & ^0x3f) == 0 && ((int64(1)<<(_la-499))&-2306265222165299201) != 0) || ((int64((_la-563)) & ^0x3f) == 0 && ((int64(1)<<(_la-563))&-35184640524289) != 0) || ((int64((_la-627)) & ^0x3f) == 0 && ((int64(1)<<(_la-627))&9222105399459575807) != 0) || ((int64((_la-698)) & ^0x3f) == 0 && ((int64(1)<<(_la-698))&514225960183805) != 0) || _la == MySqlParserMEMORY || _la == MySqlParserCATALOG_NAME || _la == MySqlParserENGINE_ATTRIBUTE || _la == MySqlParserSECONDARY_ENGINE_ATTRIBUTE || _la == MySqlParserSCHEMA_NAME || _la == MySqlParserTP_CONNECTION_ADMIN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunctionNameBaseContext is an interface to support dynamic dispatch. +type IFunctionNameBaseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ABS() antlr.TerminalNode + ACOS() antlr.TerminalNode + ADDDATE() antlr.TerminalNode + ADDTIME() antlr.TerminalNode + AES_DECRYPT() antlr.TerminalNode + AES_ENCRYPT() antlr.TerminalNode + AREA() antlr.TerminalNode + ASBINARY() antlr.TerminalNode + ASIN() antlr.TerminalNode + ASTEXT() antlr.TerminalNode + ASWKB() antlr.TerminalNode + ASWKT() antlr.TerminalNode + ASYMMETRIC_DECRYPT() antlr.TerminalNode + ASYMMETRIC_DERIVE() antlr.TerminalNode + ASYMMETRIC_ENCRYPT() antlr.TerminalNode + ASYMMETRIC_SIGN() antlr.TerminalNode + ASYMMETRIC_VERIFY() antlr.TerminalNode + ATAN() antlr.TerminalNode + ATAN2() antlr.TerminalNode + BENCHMARK() antlr.TerminalNode + BIN() antlr.TerminalNode + BIT_COUNT() antlr.TerminalNode + BIT_LENGTH() antlr.TerminalNode + BUFFER() antlr.TerminalNode + CEIL() antlr.TerminalNode + CEILING() antlr.TerminalNode + CENTROID() antlr.TerminalNode + CHARACTER_LENGTH() antlr.TerminalNode + CHARSET() antlr.TerminalNode + CHAR_LENGTH() antlr.TerminalNode + COERCIBILITY() antlr.TerminalNode + COLLATION() antlr.TerminalNode + COMPRESS() antlr.TerminalNode + CONCAT() antlr.TerminalNode + CONCAT_WS() antlr.TerminalNode + CONNECTION_ID() antlr.TerminalNode + CONV() antlr.TerminalNode + CONVERT_TZ() antlr.TerminalNode + COS() antlr.TerminalNode + COT() antlr.TerminalNode + COUNT() antlr.TerminalNode + CRC32() antlr.TerminalNode + CREATE_ASYMMETRIC_PRIV_KEY() antlr.TerminalNode + CREATE_ASYMMETRIC_PUB_KEY() antlr.TerminalNode + CREATE_DH_PARAMETERS() antlr.TerminalNode + CREATE_DIGEST() antlr.TerminalNode + CROSSES() antlr.TerminalNode + CUME_DIST() antlr.TerminalNode + DATABASE() antlr.TerminalNode + DATE() antlr.TerminalNode + DATEDIFF() antlr.TerminalNode + DATE_FORMAT() antlr.TerminalNode + DAY() antlr.TerminalNode + DAYNAME() antlr.TerminalNode + DAYOFMONTH() antlr.TerminalNode + DAYOFWEEK() antlr.TerminalNode + DAYOFYEAR() antlr.TerminalNode + DECODE() antlr.TerminalNode + DEGREES() antlr.TerminalNode + DENSE_RANK() antlr.TerminalNode + DES_DECRYPT() antlr.TerminalNode + DES_ENCRYPT() antlr.TerminalNode + DIMENSION() antlr.TerminalNode + DISJOINT() antlr.TerminalNode + DISTANCE() antlr.TerminalNode + ELT() antlr.TerminalNode + ENCODE() antlr.TerminalNode + ENCRYPT() antlr.TerminalNode + ENDPOINT() antlr.TerminalNode + ENVELOPE() antlr.TerminalNode + EQUALS() antlr.TerminalNode + EXP() antlr.TerminalNode + EXPORT_SET() antlr.TerminalNode + EXTERIORRING() antlr.TerminalNode + EXTRACTVALUE() antlr.TerminalNode + FIELD() antlr.TerminalNode + FIND_IN_SET() antlr.TerminalNode + FIRST_VALUE() antlr.TerminalNode + FLOOR() antlr.TerminalNode + FORMAT() antlr.TerminalNode + FOUND_ROWS() antlr.TerminalNode + FROM_BASE64() antlr.TerminalNode + FROM_DAYS() antlr.TerminalNode + FROM_UNIXTIME() antlr.TerminalNode + GEOMCOLLFROMTEXT() antlr.TerminalNode + GEOMCOLLFROMWKB() antlr.TerminalNode + GEOMETRYCOLLECTION() antlr.TerminalNode + GEOMETRYCOLLECTIONFROMTEXT() antlr.TerminalNode + GEOMETRYCOLLECTIONFROMWKB() antlr.TerminalNode + GEOMETRYFROMTEXT() antlr.TerminalNode + GEOMETRYFROMWKB() antlr.TerminalNode + GEOMETRYN() antlr.TerminalNode + GEOMETRYTYPE() antlr.TerminalNode + GEOMFROMTEXT() antlr.TerminalNode + GEOMFROMWKB() antlr.TerminalNode + GET_FORMAT() antlr.TerminalNode + GET_LOCK() antlr.TerminalNode + GLENGTH() antlr.TerminalNode + GREATEST() antlr.TerminalNode + GTID_SUBSET() antlr.TerminalNode + GTID_SUBTRACT() antlr.TerminalNode + HEX() antlr.TerminalNode + HOUR() antlr.TerminalNode + IFNULL() antlr.TerminalNode + INET6_ATON() antlr.TerminalNode + INET6_NTOA() antlr.TerminalNode + INET_ATON() antlr.TerminalNode + INET_NTOA() antlr.TerminalNode + INSTR() antlr.TerminalNode + INTERIORRINGN() antlr.TerminalNode + INTERSECTS() antlr.TerminalNode + INVISIBLE() antlr.TerminalNode + ISCLOSED() antlr.TerminalNode + ISEMPTY() antlr.TerminalNode + ISNULL() antlr.TerminalNode + ISSIMPLE() antlr.TerminalNode + IS_FREE_LOCK() antlr.TerminalNode + IS_IPV4() antlr.TerminalNode + IS_IPV4_COMPAT() antlr.TerminalNode + IS_IPV4_MAPPED() antlr.TerminalNode + IS_IPV6() antlr.TerminalNode + IS_USED_LOCK() antlr.TerminalNode + LAG() antlr.TerminalNode + LAST_INSERT_ID() antlr.TerminalNode + LAST_VALUE() antlr.TerminalNode + LCASE() antlr.TerminalNode + LEAD() antlr.TerminalNode + LEAST() antlr.TerminalNode + LEFT() antlr.TerminalNode + LENGTH() antlr.TerminalNode + LINEFROMTEXT() antlr.TerminalNode + LINEFROMWKB() antlr.TerminalNode + LINESTRING() antlr.TerminalNode + LINESTRINGFROMTEXT() antlr.TerminalNode + LINESTRINGFROMWKB() antlr.TerminalNode + LN() antlr.TerminalNode + LOAD_FILE() antlr.TerminalNode + LOCATE() antlr.TerminalNode + LOG() antlr.TerminalNode + LOG10() antlr.TerminalNode + LOG2() antlr.TerminalNode + LOWER() antlr.TerminalNode + LPAD() antlr.TerminalNode + LTRIM() antlr.TerminalNode + MAKEDATE() antlr.TerminalNode + MAKETIME() antlr.TerminalNode + MAKE_SET() antlr.TerminalNode + MASTER_POS_WAIT() antlr.TerminalNode + MBRCONTAINS() antlr.TerminalNode + MBRDISJOINT() antlr.TerminalNode + MBREQUAL() antlr.TerminalNode + MBRINTERSECTS() antlr.TerminalNode + MBROVERLAPS() antlr.TerminalNode + MBRTOUCHES() antlr.TerminalNode + MBRWITHIN() antlr.TerminalNode + MD5() antlr.TerminalNode + MICROSECOND() antlr.TerminalNode + MINUTE() antlr.TerminalNode + MLINEFROMTEXT() antlr.TerminalNode + MLINEFROMWKB() antlr.TerminalNode + MOD() antlr.TerminalNode + MONTH() antlr.TerminalNode + MONTHNAME() antlr.TerminalNode + MPOINTFROMTEXT() antlr.TerminalNode + MPOINTFROMWKB() antlr.TerminalNode + MPOLYFROMTEXT() antlr.TerminalNode + MPOLYFROMWKB() antlr.TerminalNode + MULTILINESTRING() antlr.TerminalNode + MULTILINESTRINGFROMTEXT() antlr.TerminalNode + MULTILINESTRINGFROMWKB() antlr.TerminalNode + MULTIPOINT() antlr.TerminalNode + MULTIPOINTFROMTEXT() antlr.TerminalNode + MULTIPOINTFROMWKB() antlr.TerminalNode + MULTIPOLYGON() antlr.TerminalNode + MULTIPOLYGONFROMTEXT() antlr.TerminalNode + MULTIPOLYGONFROMWKB() antlr.TerminalNode + NAME_CONST() antlr.TerminalNode + NTH_VALUE() antlr.TerminalNode + NTILE() antlr.TerminalNode + NULLIF() antlr.TerminalNode + NUMGEOMETRIES() antlr.TerminalNode + NUMINTERIORRINGS() antlr.TerminalNode + NUMPOINTS() antlr.TerminalNode + OCT() antlr.TerminalNode + OCTET_LENGTH() antlr.TerminalNode + ORD() antlr.TerminalNode + OVERLAPS() antlr.TerminalNode + PERCENT_RANK() antlr.TerminalNode + PERIOD_ADD() antlr.TerminalNode + PERIOD_DIFF() antlr.TerminalNode + PI() antlr.TerminalNode + POINT() antlr.TerminalNode + POINTFROMTEXT() antlr.TerminalNode + POINTFROMWKB() antlr.TerminalNode + POINTN() antlr.TerminalNode + POLYFROMTEXT() antlr.TerminalNode + POLYFROMWKB() antlr.TerminalNode + POLYGON() antlr.TerminalNode + POLYGONFROMTEXT() antlr.TerminalNode + POLYGONFROMWKB() antlr.TerminalNode + POSITION() antlr.TerminalNode + POW() antlr.TerminalNode + POWER() antlr.TerminalNode + QUARTER() antlr.TerminalNode + QUOTE() antlr.TerminalNode + RADIANS() antlr.TerminalNode + RAND() antlr.TerminalNode + RANDOM() antlr.TerminalNode + RANK() antlr.TerminalNode + RANDOM_BYTES() antlr.TerminalNode + RELEASE_LOCK() antlr.TerminalNode + REVERSE() antlr.TerminalNode + RIGHT() antlr.TerminalNode + ROUND() antlr.TerminalNode + ROW_COUNT() antlr.TerminalNode + ROW_NUMBER() antlr.TerminalNode + RPAD() antlr.TerminalNode + RTRIM() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + SECOND() antlr.TerminalNode + SEC_TO_TIME() antlr.TerminalNode + SESSION_USER() antlr.TerminalNode + SESSION_VARIABLES_ADMIN() antlr.TerminalNode + SHA() antlr.TerminalNode + SHA1() antlr.TerminalNode + SHA2() antlr.TerminalNode + SIGN() antlr.TerminalNode + SIN() antlr.TerminalNode + SLEEP() antlr.TerminalNode + SOUNDEX() antlr.TerminalNode + SQL_THREAD_WAIT_AFTER_GTIDS() antlr.TerminalNode + SQRT() antlr.TerminalNode + SRID() antlr.TerminalNode + STARTPOINT() antlr.TerminalNode + STRCMP() antlr.TerminalNode + STR_TO_DATE() antlr.TerminalNode + ST_AREA() antlr.TerminalNode + ST_ASBINARY() antlr.TerminalNode + ST_ASTEXT() antlr.TerminalNode + ST_ASWKB() antlr.TerminalNode + ST_ASWKT() antlr.TerminalNode + ST_BUFFER() antlr.TerminalNode + ST_CENTROID() antlr.TerminalNode + ST_CONTAINS() antlr.TerminalNode + ST_CROSSES() antlr.TerminalNode + ST_DIFFERENCE() antlr.TerminalNode + ST_DIMENSION() antlr.TerminalNode + ST_DISJOINT() antlr.TerminalNode + ST_DISTANCE() antlr.TerminalNode + ST_ENDPOINT() antlr.TerminalNode + ST_ENVELOPE() antlr.TerminalNode + ST_EQUALS() antlr.TerminalNode + ST_EXTERIORRING() antlr.TerminalNode + ST_GEOMCOLLFROMTEXT() antlr.TerminalNode + ST_GEOMCOLLFROMTXT() antlr.TerminalNode + ST_GEOMCOLLFROMWKB() antlr.TerminalNode + ST_GEOMETRYCOLLECTIONFROMTEXT() antlr.TerminalNode + ST_GEOMETRYCOLLECTIONFROMWKB() antlr.TerminalNode + ST_GEOMETRYFROMTEXT() antlr.TerminalNode + ST_GEOMETRYFROMWKB() antlr.TerminalNode + ST_GEOMETRYN() antlr.TerminalNode + ST_GEOMETRYTYPE() antlr.TerminalNode + ST_GEOMFROMTEXT() antlr.TerminalNode + ST_GEOMFROMWKB() antlr.TerminalNode + ST_INTERIORRINGN() antlr.TerminalNode + ST_INTERSECTION() antlr.TerminalNode + ST_INTERSECTS() antlr.TerminalNode + ST_ISCLOSED() antlr.TerminalNode + ST_ISEMPTY() antlr.TerminalNode + ST_ISSIMPLE() antlr.TerminalNode + ST_LINEFROMTEXT() antlr.TerminalNode + ST_LINEFROMWKB() antlr.TerminalNode + ST_LINESTRINGFROMTEXT() antlr.TerminalNode + ST_LINESTRINGFROMWKB() antlr.TerminalNode + ST_NUMGEOMETRIES() antlr.TerminalNode + ST_NUMINTERIORRING() antlr.TerminalNode + ST_NUMINTERIORRINGS() antlr.TerminalNode + ST_NUMPOINTS() antlr.TerminalNode + ST_OVERLAPS() antlr.TerminalNode + ST_POINTFROMTEXT() antlr.TerminalNode + ST_POINTFROMWKB() antlr.TerminalNode + ST_POINTN() antlr.TerminalNode + ST_POLYFROMTEXT() antlr.TerminalNode + ST_POLYFROMWKB() antlr.TerminalNode + ST_POLYGONFROMTEXT() antlr.TerminalNode + ST_POLYGONFROMWKB() antlr.TerminalNode + ST_SRID() antlr.TerminalNode + ST_STARTPOINT() antlr.TerminalNode + ST_SYMDIFFERENCE() antlr.TerminalNode + ST_TOUCHES() antlr.TerminalNode + ST_UNION() antlr.TerminalNode + ST_WITHIN() antlr.TerminalNode + ST_X() antlr.TerminalNode + ST_Y() antlr.TerminalNode + STRING_TO_VECTOR() antlr.TerminalNode + SUBDATE() antlr.TerminalNode + SUBSTRING_INDEX() antlr.TerminalNode + SUBTIME() antlr.TerminalNode + SYSTEM_USER() antlr.TerminalNode + TAN() antlr.TerminalNode + TIME() antlr.TerminalNode + TIMEDIFF() antlr.TerminalNode + TIMESTAMP() antlr.TerminalNode + TIMESTAMPADD() antlr.TerminalNode + TIMESTAMPDIFF() antlr.TerminalNode + TIME_FORMAT() antlr.TerminalNode + TIME_TO_SEC() antlr.TerminalNode + TOUCHES() antlr.TerminalNode + TO_BASE64() antlr.TerminalNode + TO_DAYS() antlr.TerminalNode + TO_SECONDS() antlr.TerminalNode + UCASE() antlr.TerminalNode + UNCOMPRESS() antlr.TerminalNode + UNCOMPRESSED_LENGTH() antlr.TerminalNode + UNHEX() antlr.TerminalNode + UNIX_TIMESTAMP() antlr.TerminalNode + UPDATEXML() antlr.TerminalNode + UPPER() antlr.TerminalNode + UUID() antlr.TerminalNode + UUID_SHORT() antlr.TerminalNode + VALIDATE_PASSWORD_STRENGTH() antlr.TerminalNode + VECTOR_DIM() antlr.TerminalNode + VECTOR_TO_STRING() antlr.TerminalNode + VERSION() antlr.TerminalNode + VISIBLE() antlr.TerminalNode + WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS() antlr.TerminalNode + WEEK() antlr.TerminalNode + WEEKDAY() antlr.TerminalNode + WEEKOFYEAR() antlr.TerminalNode + WEIGHT_STRING() antlr.TerminalNode + WITHIN() antlr.TerminalNode + YEAR() antlr.TerminalNode + YEARWEEK() antlr.TerminalNode + Y_FUNCTION() antlr.TerminalNode + X_FUNCTION() antlr.TerminalNode + JSON_ARRAY() antlr.TerminalNode + JSON_OBJECT() antlr.TerminalNode + JSON_QUOTE() antlr.TerminalNode + JSON_CONTAINS() antlr.TerminalNode + JSON_CONTAINS_PATH() antlr.TerminalNode + JSON_EXTRACT() antlr.TerminalNode + JSON_KEYS() antlr.TerminalNode + JSON_OVERLAPS() antlr.TerminalNode + JSON_SEARCH() antlr.TerminalNode + JSON_VALUE() antlr.TerminalNode + JSON_ARRAY_APPEND() antlr.TerminalNode + JSON_ARRAY_INSERT() antlr.TerminalNode + JSON_INSERT() antlr.TerminalNode + JSON_MERGE() antlr.TerminalNode + JSON_MERGE_PATCH() antlr.TerminalNode + JSON_MERGE_PRESERVE() antlr.TerminalNode + JSON_REMOVE() antlr.TerminalNode + JSON_REPLACE() antlr.TerminalNode + JSON_SET() antlr.TerminalNode + JSON_UNQUOTE() antlr.TerminalNode + JSON_DEPTH() antlr.TerminalNode + JSON_LENGTH() antlr.TerminalNode + JSON_TYPE() antlr.TerminalNode + JSON_VALID() antlr.TerminalNode + JSON_TABLE() antlr.TerminalNode + JSON_SCHEMA_VALID() antlr.TerminalNode + JSON_SCHEMA_VALIDATION_REPORT() antlr.TerminalNode + JSON_PRETTY() antlr.TerminalNode + JSON_STORAGE_FREE() antlr.TerminalNode + JSON_STORAGE_SIZE() antlr.TerminalNode + JSON_ARRAYAGG() antlr.TerminalNode + JSON_OBJECTAGG() antlr.TerminalNode + STATEMENT() antlr.TerminalNode + + // IsFunctionNameBaseContext differentiates from other interfaces. + IsFunctionNameBaseContext() +} + +type FunctionNameBaseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunctionNameBaseContext() *FunctionNameBaseContext { + var p = new(FunctionNameBaseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_functionNameBase + return p +} + +func InitEmptyFunctionNameBaseContext(p *FunctionNameBaseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MySqlParserRULE_functionNameBase +} + +func (*FunctionNameBaseContext) IsFunctionNameBaseContext() {} + +func NewFunctionNameBaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionNameBaseContext { + var p = new(FunctionNameBaseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MySqlParserRULE_functionNameBase + + return p +} + +func (s *FunctionNameBaseContext) GetParser() antlr.Parser { return s.parser } + +func (s *FunctionNameBaseContext) ABS() antlr.TerminalNode { + return s.GetToken(MySqlParserABS, 0) +} + +func (s *FunctionNameBaseContext) ACOS() antlr.TerminalNode { + return s.GetToken(MySqlParserACOS, 0) +} + +func (s *FunctionNameBaseContext) ADDDATE() antlr.TerminalNode { + return s.GetToken(MySqlParserADDDATE, 0) +} + +func (s *FunctionNameBaseContext) ADDTIME() antlr.TerminalNode { + return s.GetToken(MySqlParserADDTIME, 0) +} + +func (s *FunctionNameBaseContext) AES_DECRYPT() antlr.TerminalNode { + return s.GetToken(MySqlParserAES_DECRYPT, 0) +} + +func (s *FunctionNameBaseContext) AES_ENCRYPT() antlr.TerminalNode { + return s.GetToken(MySqlParserAES_ENCRYPT, 0) +} + +func (s *FunctionNameBaseContext) AREA() antlr.TerminalNode { + return s.GetToken(MySqlParserAREA, 0) +} + +func (s *FunctionNameBaseContext) ASBINARY() antlr.TerminalNode { + return s.GetToken(MySqlParserASBINARY, 0) +} + +func (s *FunctionNameBaseContext) ASIN() antlr.TerminalNode { + return s.GetToken(MySqlParserASIN, 0) +} + +func (s *FunctionNameBaseContext) ASTEXT() antlr.TerminalNode { + return s.GetToken(MySqlParserASTEXT, 0) +} + +func (s *FunctionNameBaseContext) ASWKB() antlr.TerminalNode { + return s.GetToken(MySqlParserASWKB, 0) +} + +func (s *FunctionNameBaseContext) ASWKT() antlr.TerminalNode { + return s.GetToken(MySqlParserASWKT, 0) +} + +func (s *FunctionNameBaseContext) ASYMMETRIC_DECRYPT() antlr.TerminalNode { + return s.GetToken(MySqlParserASYMMETRIC_DECRYPT, 0) +} + +func (s *FunctionNameBaseContext) ASYMMETRIC_DERIVE() antlr.TerminalNode { + return s.GetToken(MySqlParserASYMMETRIC_DERIVE, 0) +} + +func (s *FunctionNameBaseContext) ASYMMETRIC_ENCRYPT() antlr.TerminalNode { + return s.GetToken(MySqlParserASYMMETRIC_ENCRYPT, 0) +} + +func (s *FunctionNameBaseContext) ASYMMETRIC_SIGN() antlr.TerminalNode { + return s.GetToken(MySqlParserASYMMETRIC_SIGN, 0) +} + +func (s *FunctionNameBaseContext) ASYMMETRIC_VERIFY() antlr.TerminalNode { + return s.GetToken(MySqlParserASYMMETRIC_VERIFY, 0) +} + +func (s *FunctionNameBaseContext) ATAN() antlr.TerminalNode { + return s.GetToken(MySqlParserATAN, 0) +} + +func (s *FunctionNameBaseContext) ATAN2() antlr.TerminalNode { + return s.GetToken(MySqlParserATAN2, 0) +} + +func (s *FunctionNameBaseContext) BENCHMARK() antlr.TerminalNode { + return s.GetToken(MySqlParserBENCHMARK, 0) +} + +func (s *FunctionNameBaseContext) BIN() antlr.TerminalNode { + return s.GetToken(MySqlParserBIN, 0) +} + +func (s *FunctionNameBaseContext) BIT_COUNT() antlr.TerminalNode { + return s.GetToken(MySqlParserBIT_COUNT, 0) +} + +func (s *FunctionNameBaseContext) BIT_LENGTH() antlr.TerminalNode { + return s.GetToken(MySqlParserBIT_LENGTH, 0) +} + +func (s *FunctionNameBaseContext) BUFFER() antlr.TerminalNode { + return s.GetToken(MySqlParserBUFFER, 0) +} + +func (s *FunctionNameBaseContext) CEIL() antlr.TerminalNode { + return s.GetToken(MySqlParserCEIL, 0) +} + +func (s *FunctionNameBaseContext) CEILING() antlr.TerminalNode { + return s.GetToken(MySqlParserCEILING, 0) +} + +func (s *FunctionNameBaseContext) CENTROID() antlr.TerminalNode { + return s.GetToken(MySqlParserCENTROID, 0) +} + +func (s *FunctionNameBaseContext) CHARACTER_LENGTH() antlr.TerminalNode { + return s.GetToken(MySqlParserCHARACTER_LENGTH, 0) +} + +func (s *FunctionNameBaseContext) CHARSET() antlr.TerminalNode { + return s.GetToken(MySqlParserCHARSET, 0) +} + +func (s *FunctionNameBaseContext) CHAR_LENGTH() antlr.TerminalNode { + return s.GetToken(MySqlParserCHAR_LENGTH, 0) +} + +func (s *FunctionNameBaseContext) COERCIBILITY() antlr.TerminalNode { + return s.GetToken(MySqlParserCOERCIBILITY, 0) +} + +func (s *FunctionNameBaseContext) COLLATION() antlr.TerminalNode { + return s.GetToken(MySqlParserCOLLATION, 0) +} + +func (s *FunctionNameBaseContext) COMPRESS() antlr.TerminalNode { + return s.GetToken(MySqlParserCOMPRESS, 0) +} + +func (s *FunctionNameBaseContext) CONCAT() antlr.TerminalNode { + return s.GetToken(MySqlParserCONCAT, 0) +} + +func (s *FunctionNameBaseContext) CONCAT_WS() antlr.TerminalNode { + return s.GetToken(MySqlParserCONCAT_WS, 0) +} + +func (s *FunctionNameBaseContext) CONNECTION_ID() antlr.TerminalNode { + return s.GetToken(MySqlParserCONNECTION_ID, 0) +} + +func (s *FunctionNameBaseContext) CONV() antlr.TerminalNode { + return s.GetToken(MySqlParserCONV, 0) +} + +func (s *FunctionNameBaseContext) CONVERT_TZ() antlr.TerminalNode { + return s.GetToken(MySqlParserCONVERT_TZ, 0) +} + +func (s *FunctionNameBaseContext) COS() antlr.TerminalNode { + return s.GetToken(MySqlParserCOS, 0) +} + +func (s *FunctionNameBaseContext) COT() antlr.TerminalNode { + return s.GetToken(MySqlParserCOT, 0) +} + +func (s *FunctionNameBaseContext) COUNT() antlr.TerminalNode { + return s.GetToken(MySqlParserCOUNT, 0) +} + +func (s *FunctionNameBaseContext) CRC32() antlr.TerminalNode { + return s.GetToken(MySqlParserCRC32, 0) +} + +func (s *FunctionNameBaseContext) CREATE_ASYMMETRIC_PRIV_KEY() antlr.TerminalNode { + return s.GetToken(MySqlParserCREATE_ASYMMETRIC_PRIV_KEY, 0) +} + +func (s *FunctionNameBaseContext) CREATE_ASYMMETRIC_PUB_KEY() antlr.TerminalNode { + return s.GetToken(MySqlParserCREATE_ASYMMETRIC_PUB_KEY, 0) +} + +func (s *FunctionNameBaseContext) CREATE_DH_PARAMETERS() antlr.TerminalNode { + return s.GetToken(MySqlParserCREATE_DH_PARAMETERS, 0) +} + +func (s *FunctionNameBaseContext) CREATE_DIGEST() antlr.TerminalNode { + return s.GetToken(MySqlParserCREATE_DIGEST, 0) +} + +func (s *FunctionNameBaseContext) CROSSES() antlr.TerminalNode { + return s.GetToken(MySqlParserCROSSES, 0) +} + +func (s *FunctionNameBaseContext) CUME_DIST() antlr.TerminalNode { + return s.GetToken(MySqlParserCUME_DIST, 0) +} + +func (s *FunctionNameBaseContext) DATABASE() antlr.TerminalNode { + return s.GetToken(MySqlParserDATABASE, 0) +} + +func (s *FunctionNameBaseContext) DATE() antlr.TerminalNode { + return s.GetToken(MySqlParserDATE, 0) +} + +func (s *FunctionNameBaseContext) DATEDIFF() antlr.TerminalNode { + return s.GetToken(MySqlParserDATEDIFF, 0) +} + +func (s *FunctionNameBaseContext) DATE_FORMAT() antlr.TerminalNode { + return s.GetToken(MySqlParserDATE_FORMAT, 0) +} + +func (s *FunctionNameBaseContext) DAY() antlr.TerminalNode { + return s.GetToken(MySqlParserDAY, 0) +} + +func (s *FunctionNameBaseContext) DAYNAME() antlr.TerminalNode { + return s.GetToken(MySqlParserDAYNAME, 0) +} + +func (s *FunctionNameBaseContext) DAYOFMONTH() antlr.TerminalNode { + return s.GetToken(MySqlParserDAYOFMONTH, 0) +} + +func (s *FunctionNameBaseContext) DAYOFWEEK() antlr.TerminalNode { + return s.GetToken(MySqlParserDAYOFWEEK, 0) +} + +func (s *FunctionNameBaseContext) DAYOFYEAR() antlr.TerminalNode { + return s.GetToken(MySqlParserDAYOFYEAR, 0) +} + +func (s *FunctionNameBaseContext) DECODE() antlr.TerminalNode { + return s.GetToken(MySqlParserDECODE, 0) +} + +func (s *FunctionNameBaseContext) DEGREES() antlr.TerminalNode { + return s.GetToken(MySqlParserDEGREES, 0) +} + +func (s *FunctionNameBaseContext) DENSE_RANK() antlr.TerminalNode { + return s.GetToken(MySqlParserDENSE_RANK, 0) +} + +func (s *FunctionNameBaseContext) DES_DECRYPT() antlr.TerminalNode { + return s.GetToken(MySqlParserDES_DECRYPT, 0) +} + +func (s *FunctionNameBaseContext) DES_ENCRYPT() antlr.TerminalNode { + return s.GetToken(MySqlParserDES_ENCRYPT, 0) +} + +func (s *FunctionNameBaseContext) DIMENSION() antlr.TerminalNode { + return s.GetToken(MySqlParserDIMENSION, 0) +} + +func (s *FunctionNameBaseContext) DISJOINT() antlr.TerminalNode { + return s.GetToken(MySqlParserDISJOINT, 0) +} + +func (s *FunctionNameBaseContext) DISTANCE() antlr.TerminalNode { + return s.GetToken(MySqlParserDISTANCE, 0) +} + +func (s *FunctionNameBaseContext) ELT() antlr.TerminalNode { + return s.GetToken(MySqlParserELT, 0) +} + +func (s *FunctionNameBaseContext) ENCODE() antlr.TerminalNode { + return s.GetToken(MySqlParserENCODE, 0) +} + +func (s *FunctionNameBaseContext) ENCRYPT() antlr.TerminalNode { + return s.GetToken(MySqlParserENCRYPT, 0) +} + +func (s *FunctionNameBaseContext) ENDPOINT() antlr.TerminalNode { + return s.GetToken(MySqlParserENDPOINT, 0) +} + +func (s *FunctionNameBaseContext) ENVELOPE() antlr.TerminalNode { + return s.GetToken(MySqlParserENVELOPE, 0) +} + +func (s *FunctionNameBaseContext) EQUALS() antlr.TerminalNode { + return s.GetToken(MySqlParserEQUALS, 0) +} + +func (s *FunctionNameBaseContext) EXP() antlr.TerminalNode { + return s.GetToken(MySqlParserEXP, 0) +} + +func (s *FunctionNameBaseContext) EXPORT_SET() antlr.TerminalNode { + return s.GetToken(MySqlParserEXPORT_SET, 0) +} + +func (s *FunctionNameBaseContext) EXTERIORRING() antlr.TerminalNode { + return s.GetToken(MySqlParserEXTERIORRING, 0) +} + +func (s *FunctionNameBaseContext) EXTRACTVALUE() antlr.TerminalNode { + return s.GetToken(MySqlParserEXTRACTVALUE, 0) +} + +func (s *FunctionNameBaseContext) FIELD() antlr.TerminalNode { + return s.GetToken(MySqlParserFIELD, 0) +} + +func (s *FunctionNameBaseContext) FIND_IN_SET() antlr.TerminalNode { + return s.GetToken(MySqlParserFIND_IN_SET, 0) +} + +func (s *FunctionNameBaseContext) FIRST_VALUE() antlr.TerminalNode { + return s.GetToken(MySqlParserFIRST_VALUE, 0) +} + +func (s *FunctionNameBaseContext) FLOOR() antlr.TerminalNode { + return s.GetToken(MySqlParserFLOOR, 0) +} + +func (s *FunctionNameBaseContext) FORMAT() antlr.TerminalNode { + return s.GetToken(MySqlParserFORMAT, 0) +} + +func (s *FunctionNameBaseContext) FOUND_ROWS() antlr.TerminalNode { + return s.GetToken(MySqlParserFOUND_ROWS, 0) +} + +func (s *FunctionNameBaseContext) FROM_BASE64() antlr.TerminalNode { + return s.GetToken(MySqlParserFROM_BASE64, 0) +} + +func (s *FunctionNameBaseContext) FROM_DAYS() antlr.TerminalNode { + return s.GetToken(MySqlParserFROM_DAYS, 0) +} + +func (s *FunctionNameBaseContext) FROM_UNIXTIME() antlr.TerminalNode { + return s.GetToken(MySqlParserFROM_UNIXTIME, 0) +} + +func (s *FunctionNameBaseContext) GEOMCOLLFROMTEXT() antlr.TerminalNode { + return s.GetToken(MySqlParserGEOMCOLLFROMTEXT, 0) +} + +func (s *FunctionNameBaseContext) GEOMCOLLFROMWKB() antlr.TerminalNode { + return s.GetToken(MySqlParserGEOMCOLLFROMWKB, 0) +} + +func (s *FunctionNameBaseContext) GEOMETRYCOLLECTION() antlr.TerminalNode { + return s.GetToken(MySqlParserGEOMETRYCOLLECTION, 0) +} + +func (s *FunctionNameBaseContext) GEOMETRYCOLLECTIONFROMTEXT() antlr.TerminalNode { + return s.GetToken(MySqlParserGEOMETRYCOLLECTIONFROMTEXT, 0) +} + +func (s *FunctionNameBaseContext) GEOMETRYCOLLECTIONFROMWKB() antlr.TerminalNode { + return s.GetToken(MySqlParserGEOMETRYCOLLECTIONFROMWKB, 0) +} + +func (s *FunctionNameBaseContext) GEOMETRYFROMTEXT() antlr.TerminalNode { + return s.GetToken(MySqlParserGEOMETRYFROMTEXT, 0) +} + +func (s *FunctionNameBaseContext) GEOMETRYFROMWKB() antlr.TerminalNode { + return s.GetToken(MySqlParserGEOMETRYFROMWKB, 0) +} + +func (s *FunctionNameBaseContext) GEOMETRYN() antlr.TerminalNode { + return s.GetToken(MySqlParserGEOMETRYN, 0) +} + +func (s *FunctionNameBaseContext) GEOMETRYTYPE() antlr.TerminalNode { + return s.GetToken(MySqlParserGEOMETRYTYPE, 0) +} + +func (s *FunctionNameBaseContext) GEOMFROMTEXT() antlr.TerminalNode { + return s.GetToken(MySqlParserGEOMFROMTEXT, 0) +} + +func (s *FunctionNameBaseContext) GEOMFROMWKB() antlr.TerminalNode { + return s.GetToken(MySqlParserGEOMFROMWKB, 0) +} + +func (s *FunctionNameBaseContext) GET_FORMAT() antlr.TerminalNode { + return s.GetToken(MySqlParserGET_FORMAT, 0) +} + +func (s *FunctionNameBaseContext) GET_LOCK() antlr.TerminalNode { + return s.GetToken(MySqlParserGET_LOCK, 0) +} + +func (s *FunctionNameBaseContext) GLENGTH() antlr.TerminalNode { + return s.GetToken(MySqlParserGLENGTH, 0) +} + +func (s *FunctionNameBaseContext) GREATEST() antlr.TerminalNode { + return s.GetToken(MySqlParserGREATEST, 0) +} + +func (s *FunctionNameBaseContext) GTID_SUBSET() antlr.TerminalNode { + return s.GetToken(MySqlParserGTID_SUBSET, 0) +} + +func (s *FunctionNameBaseContext) GTID_SUBTRACT() antlr.TerminalNode { + return s.GetToken(MySqlParserGTID_SUBTRACT, 0) +} + +func (s *FunctionNameBaseContext) HEX() antlr.TerminalNode { + return s.GetToken(MySqlParserHEX, 0) +} + +func (s *FunctionNameBaseContext) HOUR() antlr.TerminalNode { + return s.GetToken(MySqlParserHOUR, 0) +} + +func (s *FunctionNameBaseContext) IFNULL() antlr.TerminalNode { + return s.GetToken(MySqlParserIFNULL, 0) +} + +func (s *FunctionNameBaseContext) INET6_ATON() antlr.TerminalNode { + return s.GetToken(MySqlParserINET6_ATON, 0) +} + +func (s *FunctionNameBaseContext) INET6_NTOA() antlr.TerminalNode { + return s.GetToken(MySqlParserINET6_NTOA, 0) +} + +func (s *FunctionNameBaseContext) INET_ATON() antlr.TerminalNode { + return s.GetToken(MySqlParserINET_ATON, 0) +} + +func (s *FunctionNameBaseContext) INET_NTOA() antlr.TerminalNode { + return s.GetToken(MySqlParserINET_NTOA, 0) +} + +func (s *FunctionNameBaseContext) INSTR() antlr.TerminalNode { + return s.GetToken(MySqlParserINSTR, 0) +} + +func (s *FunctionNameBaseContext) INTERIORRINGN() antlr.TerminalNode { + return s.GetToken(MySqlParserINTERIORRINGN, 0) +} + +func (s *FunctionNameBaseContext) INTERSECTS() antlr.TerminalNode { + return s.GetToken(MySqlParserINTERSECTS, 0) +} + +func (s *FunctionNameBaseContext) INVISIBLE() antlr.TerminalNode { + return s.GetToken(MySqlParserINVISIBLE, 0) +} + +func (s *FunctionNameBaseContext) ISCLOSED() antlr.TerminalNode { + return s.GetToken(MySqlParserISCLOSED, 0) +} + +func (s *FunctionNameBaseContext) ISEMPTY() antlr.TerminalNode { + return s.GetToken(MySqlParserISEMPTY, 0) +} + +func (s *FunctionNameBaseContext) ISNULL() antlr.TerminalNode { + return s.GetToken(MySqlParserISNULL, 0) +} + +func (s *FunctionNameBaseContext) ISSIMPLE() antlr.TerminalNode { + return s.GetToken(MySqlParserISSIMPLE, 0) +} + +func (s *FunctionNameBaseContext) IS_FREE_LOCK() antlr.TerminalNode { + return s.GetToken(MySqlParserIS_FREE_LOCK, 0) +} + +func (s *FunctionNameBaseContext) IS_IPV4() antlr.TerminalNode { + return s.GetToken(MySqlParserIS_IPV4, 0) +} + +func (s *FunctionNameBaseContext) IS_IPV4_COMPAT() antlr.TerminalNode { + return s.GetToken(MySqlParserIS_IPV4_COMPAT, 0) +} + +func (s *FunctionNameBaseContext) IS_IPV4_MAPPED() antlr.TerminalNode { + return s.GetToken(MySqlParserIS_IPV4_MAPPED, 0) +} + +func (s *FunctionNameBaseContext) IS_IPV6() antlr.TerminalNode { + return s.GetToken(MySqlParserIS_IPV6, 0) +} + +func (s *FunctionNameBaseContext) IS_USED_LOCK() antlr.TerminalNode { + return s.GetToken(MySqlParserIS_USED_LOCK, 0) +} + +func (s *FunctionNameBaseContext) LAG() antlr.TerminalNode { + return s.GetToken(MySqlParserLAG, 0) +} + +func (s *FunctionNameBaseContext) LAST_INSERT_ID() antlr.TerminalNode { + return s.GetToken(MySqlParserLAST_INSERT_ID, 0) +} + +func (s *FunctionNameBaseContext) LAST_VALUE() antlr.TerminalNode { + return s.GetToken(MySqlParserLAST_VALUE, 0) +} + +func (s *FunctionNameBaseContext) LCASE() antlr.TerminalNode { + return s.GetToken(MySqlParserLCASE, 0) +} + +func (s *FunctionNameBaseContext) LEAD() antlr.TerminalNode { + return s.GetToken(MySqlParserLEAD, 0) +} + +func (s *FunctionNameBaseContext) LEAST() antlr.TerminalNode { + return s.GetToken(MySqlParserLEAST, 0) +} + +func (s *FunctionNameBaseContext) LEFT() antlr.TerminalNode { + return s.GetToken(MySqlParserLEFT, 0) +} + +func (s *FunctionNameBaseContext) LENGTH() antlr.TerminalNode { + return s.GetToken(MySqlParserLENGTH, 0) +} + +func (s *FunctionNameBaseContext) LINEFROMTEXT() antlr.TerminalNode { + return s.GetToken(MySqlParserLINEFROMTEXT, 0) +} + +func (s *FunctionNameBaseContext) LINEFROMWKB() antlr.TerminalNode { + return s.GetToken(MySqlParserLINEFROMWKB, 0) +} + +func (s *FunctionNameBaseContext) LINESTRING() antlr.TerminalNode { + return s.GetToken(MySqlParserLINESTRING, 0) +} + +func (s *FunctionNameBaseContext) LINESTRINGFROMTEXT() antlr.TerminalNode { + return s.GetToken(MySqlParserLINESTRINGFROMTEXT, 0) +} + +func (s *FunctionNameBaseContext) LINESTRINGFROMWKB() antlr.TerminalNode { + return s.GetToken(MySqlParserLINESTRINGFROMWKB, 0) +} + +func (s *FunctionNameBaseContext) LN() antlr.TerminalNode { + return s.GetToken(MySqlParserLN, 0) +} + +func (s *FunctionNameBaseContext) LOAD_FILE() antlr.TerminalNode { + return s.GetToken(MySqlParserLOAD_FILE, 0) +} + +func (s *FunctionNameBaseContext) LOCATE() antlr.TerminalNode { + return s.GetToken(MySqlParserLOCATE, 0) +} + +func (s *FunctionNameBaseContext) LOG() antlr.TerminalNode { + return s.GetToken(MySqlParserLOG, 0) +} + +func (s *FunctionNameBaseContext) LOG10() antlr.TerminalNode { + return s.GetToken(MySqlParserLOG10, 0) +} + +func (s *FunctionNameBaseContext) LOG2() antlr.TerminalNode { + return s.GetToken(MySqlParserLOG2, 0) +} + +func (s *FunctionNameBaseContext) LOWER() antlr.TerminalNode { + return s.GetToken(MySqlParserLOWER, 0) +} + +func (s *FunctionNameBaseContext) LPAD() antlr.TerminalNode { + return s.GetToken(MySqlParserLPAD, 0) +} + +func (s *FunctionNameBaseContext) LTRIM() antlr.TerminalNode { + return s.GetToken(MySqlParserLTRIM, 0) +} + +func (s *FunctionNameBaseContext) MAKEDATE() antlr.TerminalNode { + return s.GetToken(MySqlParserMAKEDATE, 0) +} + +func (s *FunctionNameBaseContext) MAKETIME() antlr.TerminalNode { + return s.GetToken(MySqlParserMAKETIME, 0) +} + +func (s *FunctionNameBaseContext) MAKE_SET() antlr.TerminalNode { + return s.GetToken(MySqlParserMAKE_SET, 0) +} + +func (s *FunctionNameBaseContext) MASTER_POS_WAIT() antlr.TerminalNode { + return s.GetToken(MySqlParserMASTER_POS_WAIT, 0) +} + +func (s *FunctionNameBaseContext) MBRCONTAINS() antlr.TerminalNode { + return s.GetToken(MySqlParserMBRCONTAINS, 0) +} + +func (s *FunctionNameBaseContext) MBRDISJOINT() antlr.TerminalNode { + return s.GetToken(MySqlParserMBRDISJOINT, 0) +} + +func (s *FunctionNameBaseContext) MBREQUAL() antlr.TerminalNode { + return s.GetToken(MySqlParserMBREQUAL, 0) +} + +func (s *FunctionNameBaseContext) MBRINTERSECTS() antlr.TerminalNode { + return s.GetToken(MySqlParserMBRINTERSECTS, 0) +} + +func (s *FunctionNameBaseContext) MBROVERLAPS() antlr.TerminalNode { + return s.GetToken(MySqlParserMBROVERLAPS, 0) +} + +func (s *FunctionNameBaseContext) MBRTOUCHES() antlr.TerminalNode { + return s.GetToken(MySqlParserMBRTOUCHES, 0) +} + +func (s *FunctionNameBaseContext) MBRWITHIN() antlr.TerminalNode { + return s.GetToken(MySqlParserMBRWITHIN, 0) +} + +func (s *FunctionNameBaseContext) MD5() antlr.TerminalNode { + return s.GetToken(MySqlParserMD5, 0) +} + +func (s *FunctionNameBaseContext) MICROSECOND() antlr.TerminalNode { + return s.GetToken(MySqlParserMICROSECOND, 0) +} + +func (s *FunctionNameBaseContext) MINUTE() antlr.TerminalNode { + return s.GetToken(MySqlParserMINUTE, 0) +} + +func (s *FunctionNameBaseContext) MLINEFROMTEXT() antlr.TerminalNode { + return s.GetToken(MySqlParserMLINEFROMTEXT, 0) +} + +func (s *FunctionNameBaseContext) MLINEFROMWKB() antlr.TerminalNode { + return s.GetToken(MySqlParserMLINEFROMWKB, 0) +} + +func (s *FunctionNameBaseContext) MOD() antlr.TerminalNode { + return s.GetToken(MySqlParserMOD, 0) +} + +func (s *FunctionNameBaseContext) MONTH() antlr.TerminalNode { + return s.GetToken(MySqlParserMONTH, 0) +} + +func (s *FunctionNameBaseContext) MONTHNAME() antlr.TerminalNode { + return s.GetToken(MySqlParserMONTHNAME, 0) +} + +func (s *FunctionNameBaseContext) MPOINTFROMTEXT() antlr.TerminalNode { + return s.GetToken(MySqlParserMPOINTFROMTEXT, 0) +} + +func (s *FunctionNameBaseContext) MPOINTFROMWKB() antlr.TerminalNode { + return s.GetToken(MySqlParserMPOINTFROMWKB, 0) +} + +func (s *FunctionNameBaseContext) MPOLYFROMTEXT() antlr.TerminalNode { + return s.GetToken(MySqlParserMPOLYFROMTEXT, 0) +} + +func (s *FunctionNameBaseContext) MPOLYFROMWKB() antlr.TerminalNode { + return s.GetToken(MySqlParserMPOLYFROMWKB, 0) +} + +func (s *FunctionNameBaseContext) MULTILINESTRING() antlr.TerminalNode { + return s.GetToken(MySqlParserMULTILINESTRING, 0) +} + +func (s *FunctionNameBaseContext) MULTILINESTRINGFROMTEXT() antlr.TerminalNode { + return s.GetToken(MySqlParserMULTILINESTRINGFROMTEXT, 0) +} + +func (s *FunctionNameBaseContext) MULTILINESTRINGFROMWKB() antlr.TerminalNode { + return s.GetToken(MySqlParserMULTILINESTRINGFROMWKB, 0) +} + +func (s *FunctionNameBaseContext) MULTIPOINT() antlr.TerminalNode { + return s.GetToken(MySqlParserMULTIPOINT, 0) +} + +func (s *FunctionNameBaseContext) MULTIPOINTFROMTEXT() antlr.TerminalNode { + return s.GetToken(MySqlParserMULTIPOINTFROMTEXT, 0) +} + +func (s *FunctionNameBaseContext) MULTIPOINTFROMWKB() antlr.TerminalNode { + return s.GetToken(MySqlParserMULTIPOINTFROMWKB, 0) +} + +func (s *FunctionNameBaseContext) MULTIPOLYGON() antlr.TerminalNode { + return s.GetToken(MySqlParserMULTIPOLYGON, 0) +} + +func (s *FunctionNameBaseContext) MULTIPOLYGONFROMTEXT() antlr.TerminalNode { + return s.GetToken(MySqlParserMULTIPOLYGONFROMTEXT, 0) +} + +func (s *FunctionNameBaseContext) MULTIPOLYGONFROMWKB() antlr.TerminalNode { + return s.GetToken(MySqlParserMULTIPOLYGONFROMWKB, 0) +} + +func (s *FunctionNameBaseContext) NAME_CONST() antlr.TerminalNode { + return s.GetToken(MySqlParserNAME_CONST, 0) +} + +func (s *FunctionNameBaseContext) NTH_VALUE() antlr.TerminalNode { + return s.GetToken(MySqlParserNTH_VALUE, 0) +} + +func (s *FunctionNameBaseContext) NTILE() antlr.TerminalNode { + return s.GetToken(MySqlParserNTILE, 0) +} + +func (s *FunctionNameBaseContext) NULLIF() antlr.TerminalNode { + return s.GetToken(MySqlParserNULLIF, 0) +} + +func (s *FunctionNameBaseContext) NUMGEOMETRIES() antlr.TerminalNode { + return s.GetToken(MySqlParserNUMGEOMETRIES, 0) +} + +func (s *FunctionNameBaseContext) NUMINTERIORRINGS() antlr.TerminalNode { + return s.GetToken(MySqlParserNUMINTERIORRINGS, 0) +} + +func (s *FunctionNameBaseContext) NUMPOINTS() antlr.TerminalNode { + return s.GetToken(MySqlParserNUMPOINTS, 0) +} + +func (s *FunctionNameBaseContext) OCT() antlr.TerminalNode { + return s.GetToken(MySqlParserOCT, 0) +} + +func (s *FunctionNameBaseContext) OCTET_LENGTH() antlr.TerminalNode { + return s.GetToken(MySqlParserOCTET_LENGTH, 0) +} + +func (s *FunctionNameBaseContext) ORD() antlr.TerminalNode { + return s.GetToken(MySqlParserORD, 0) +} + +func (s *FunctionNameBaseContext) OVERLAPS() antlr.TerminalNode { + return s.GetToken(MySqlParserOVERLAPS, 0) +} + +func (s *FunctionNameBaseContext) PERCENT_RANK() antlr.TerminalNode { + return s.GetToken(MySqlParserPERCENT_RANK, 0) +} + +func (s *FunctionNameBaseContext) PERIOD_ADD() antlr.TerminalNode { + return s.GetToken(MySqlParserPERIOD_ADD, 0) +} + +func (s *FunctionNameBaseContext) PERIOD_DIFF() antlr.TerminalNode { + return s.GetToken(MySqlParserPERIOD_DIFF, 0) +} + +func (s *FunctionNameBaseContext) PI() antlr.TerminalNode { + return s.GetToken(MySqlParserPI, 0) +} + +func (s *FunctionNameBaseContext) POINT() antlr.TerminalNode { + return s.GetToken(MySqlParserPOINT, 0) +} + +func (s *FunctionNameBaseContext) POINTFROMTEXT() antlr.TerminalNode { + return s.GetToken(MySqlParserPOINTFROMTEXT, 0) +} + +func (s *FunctionNameBaseContext) POINTFROMWKB() antlr.TerminalNode { + return s.GetToken(MySqlParserPOINTFROMWKB, 0) +} + +func (s *FunctionNameBaseContext) POINTN() antlr.TerminalNode { + return s.GetToken(MySqlParserPOINTN, 0) +} + +func (s *FunctionNameBaseContext) POLYFROMTEXT() antlr.TerminalNode { + return s.GetToken(MySqlParserPOLYFROMTEXT, 0) +} + +func (s *FunctionNameBaseContext) POLYFROMWKB() antlr.TerminalNode { + return s.GetToken(MySqlParserPOLYFROMWKB, 0) +} + +func (s *FunctionNameBaseContext) POLYGON() antlr.TerminalNode { + return s.GetToken(MySqlParserPOLYGON, 0) +} + +func (s *FunctionNameBaseContext) POLYGONFROMTEXT() antlr.TerminalNode { + return s.GetToken(MySqlParserPOLYGONFROMTEXT, 0) +} + +func (s *FunctionNameBaseContext) POLYGONFROMWKB() antlr.TerminalNode { + return s.GetToken(MySqlParserPOLYGONFROMWKB, 0) +} + +func (s *FunctionNameBaseContext) POSITION() antlr.TerminalNode { + return s.GetToken(MySqlParserPOSITION, 0) +} + +func (s *FunctionNameBaseContext) POW() antlr.TerminalNode { + return s.GetToken(MySqlParserPOW, 0) +} + +func (s *FunctionNameBaseContext) POWER() antlr.TerminalNode { + return s.GetToken(MySqlParserPOWER, 0) +} + +func (s *FunctionNameBaseContext) QUARTER() antlr.TerminalNode { + return s.GetToken(MySqlParserQUARTER, 0) +} + +func (s *FunctionNameBaseContext) QUOTE() antlr.TerminalNode { + return s.GetToken(MySqlParserQUOTE, 0) +} + +func (s *FunctionNameBaseContext) RADIANS() antlr.TerminalNode { + return s.GetToken(MySqlParserRADIANS, 0) +} + +func (s *FunctionNameBaseContext) RAND() antlr.TerminalNode { + return s.GetToken(MySqlParserRAND, 0) +} + +func (s *FunctionNameBaseContext) RANDOM() antlr.TerminalNode { + return s.GetToken(MySqlParserRANDOM, 0) +} + +func (s *FunctionNameBaseContext) RANK() antlr.TerminalNode { + return s.GetToken(MySqlParserRANK, 0) +} + +func (s *FunctionNameBaseContext) RANDOM_BYTES() antlr.TerminalNode { + return s.GetToken(MySqlParserRANDOM_BYTES, 0) +} + +func (s *FunctionNameBaseContext) RELEASE_LOCK() antlr.TerminalNode { + return s.GetToken(MySqlParserRELEASE_LOCK, 0) +} + +func (s *FunctionNameBaseContext) REVERSE() antlr.TerminalNode { + return s.GetToken(MySqlParserREVERSE, 0) +} + +func (s *FunctionNameBaseContext) RIGHT() antlr.TerminalNode { + return s.GetToken(MySqlParserRIGHT, 0) +} + +func (s *FunctionNameBaseContext) ROUND() antlr.TerminalNode { + return s.GetToken(MySqlParserROUND, 0) +} + +func (s *FunctionNameBaseContext) ROW_COUNT() antlr.TerminalNode { + return s.GetToken(MySqlParserROW_COUNT, 0) +} + +func (s *FunctionNameBaseContext) ROW_NUMBER() antlr.TerminalNode { + return s.GetToken(MySqlParserROW_NUMBER, 0) +} + +func (s *FunctionNameBaseContext) RPAD() antlr.TerminalNode { + return s.GetToken(MySqlParserRPAD, 0) +} + +func (s *FunctionNameBaseContext) RTRIM() antlr.TerminalNode { + return s.GetToken(MySqlParserRTRIM, 0) +} + +func (s *FunctionNameBaseContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(MySqlParserSCHEMA, 0) +} + +func (s *FunctionNameBaseContext) SECOND() antlr.TerminalNode { + return s.GetToken(MySqlParserSECOND, 0) +} + +func (s *FunctionNameBaseContext) SEC_TO_TIME() antlr.TerminalNode { + return s.GetToken(MySqlParserSEC_TO_TIME, 0) +} + +func (s *FunctionNameBaseContext) SESSION_USER() antlr.TerminalNode { + return s.GetToken(MySqlParserSESSION_USER, 0) +} + +func (s *FunctionNameBaseContext) SESSION_VARIABLES_ADMIN() antlr.TerminalNode { + return s.GetToken(MySqlParserSESSION_VARIABLES_ADMIN, 0) +} + +func (s *FunctionNameBaseContext) SHA() antlr.TerminalNode { + return s.GetToken(MySqlParserSHA, 0) +} + +func (s *FunctionNameBaseContext) SHA1() antlr.TerminalNode { + return s.GetToken(MySqlParserSHA1, 0) +} + +func (s *FunctionNameBaseContext) SHA2() antlr.TerminalNode { + return s.GetToken(MySqlParserSHA2, 0) +} + +func (s *FunctionNameBaseContext) SIGN() antlr.TerminalNode { + return s.GetToken(MySqlParserSIGN, 0) +} + +func (s *FunctionNameBaseContext) SIN() antlr.TerminalNode { + return s.GetToken(MySqlParserSIN, 0) +} + +func (s *FunctionNameBaseContext) SLEEP() antlr.TerminalNode { + return s.GetToken(MySqlParserSLEEP, 0) +} + +func (s *FunctionNameBaseContext) SOUNDEX() antlr.TerminalNode { + return s.GetToken(MySqlParserSOUNDEX, 0) +} + +func (s *FunctionNameBaseContext) SQL_THREAD_WAIT_AFTER_GTIDS() antlr.TerminalNode { + return s.GetToken(MySqlParserSQL_THREAD_WAIT_AFTER_GTIDS, 0) +} + +func (s *FunctionNameBaseContext) SQRT() antlr.TerminalNode { + return s.GetToken(MySqlParserSQRT, 0) +} + +func (s *FunctionNameBaseContext) SRID() antlr.TerminalNode { + return s.GetToken(MySqlParserSRID, 0) +} + +func (s *FunctionNameBaseContext) STARTPOINT() antlr.TerminalNode { + return s.GetToken(MySqlParserSTARTPOINT, 0) +} + +func (s *FunctionNameBaseContext) STRCMP() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRCMP, 0) +} + +func (s *FunctionNameBaseContext) STR_TO_DATE() antlr.TerminalNode { + return s.GetToken(MySqlParserSTR_TO_DATE, 0) +} + +func (s *FunctionNameBaseContext) ST_AREA() antlr.TerminalNode { + return s.GetToken(MySqlParserST_AREA, 0) +} + +func (s *FunctionNameBaseContext) ST_ASBINARY() antlr.TerminalNode { + return s.GetToken(MySqlParserST_ASBINARY, 0) +} + +func (s *FunctionNameBaseContext) ST_ASTEXT() antlr.TerminalNode { + return s.GetToken(MySqlParserST_ASTEXT, 0) +} + +func (s *FunctionNameBaseContext) ST_ASWKB() antlr.TerminalNode { + return s.GetToken(MySqlParserST_ASWKB, 0) +} + +func (s *FunctionNameBaseContext) ST_ASWKT() antlr.TerminalNode { + return s.GetToken(MySqlParserST_ASWKT, 0) +} + +func (s *FunctionNameBaseContext) ST_BUFFER() antlr.TerminalNode { + return s.GetToken(MySqlParserST_BUFFER, 0) +} + +func (s *FunctionNameBaseContext) ST_CENTROID() antlr.TerminalNode { + return s.GetToken(MySqlParserST_CENTROID, 0) +} + +func (s *FunctionNameBaseContext) ST_CONTAINS() antlr.TerminalNode { + return s.GetToken(MySqlParserST_CONTAINS, 0) +} + +func (s *FunctionNameBaseContext) ST_CROSSES() antlr.TerminalNode { + return s.GetToken(MySqlParserST_CROSSES, 0) +} + +func (s *FunctionNameBaseContext) ST_DIFFERENCE() antlr.TerminalNode { + return s.GetToken(MySqlParserST_DIFFERENCE, 0) +} + +func (s *FunctionNameBaseContext) ST_DIMENSION() antlr.TerminalNode { + return s.GetToken(MySqlParserST_DIMENSION, 0) +} + +func (s *FunctionNameBaseContext) ST_DISJOINT() antlr.TerminalNode { + return s.GetToken(MySqlParserST_DISJOINT, 0) +} + +func (s *FunctionNameBaseContext) ST_DISTANCE() antlr.TerminalNode { + return s.GetToken(MySqlParserST_DISTANCE, 0) +} + +func (s *FunctionNameBaseContext) ST_ENDPOINT() antlr.TerminalNode { + return s.GetToken(MySqlParserST_ENDPOINT, 0) +} + +func (s *FunctionNameBaseContext) ST_ENVELOPE() antlr.TerminalNode { + return s.GetToken(MySqlParserST_ENVELOPE, 0) +} + +func (s *FunctionNameBaseContext) ST_EQUALS() antlr.TerminalNode { + return s.GetToken(MySqlParserST_EQUALS, 0) +} + +func (s *FunctionNameBaseContext) ST_EXTERIORRING() antlr.TerminalNode { + return s.GetToken(MySqlParserST_EXTERIORRING, 0) +} + +func (s *FunctionNameBaseContext) ST_GEOMCOLLFROMTEXT() antlr.TerminalNode { + return s.GetToken(MySqlParserST_GEOMCOLLFROMTEXT, 0) +} + +func (s *FunctionNameBaseContext) ST_GEOMCOLLFROMTXT() antlr.TerminalNode { + return s.GetToken(MySqlParserST_GEOMCOLLFROMTXT, 0) +} + +func (s *FunctionNameBaseContext) ST_GEOMCOLLFROMWKB() antlr.TerminalNode { + return s.GetToken(MySqlParserST_GEOMCOLLFROMWKB, 0) +} + +func (s *FunctionNameBaseContext) ST_GEOMETRYCOLLECTIONFROMTEXT() antlr.TerminalNode { + return s.GetToken(MySqlParserST_GEOMETRYCOLLECTIONFROMTEXT, 0) +} + +func (s *FunctionNameBaseContext) ST_GEOMETRYCOLLECTIONFROMWKB() antlr.TerminalNode { + return s.GetToken(MySqlParserST_GEOMETRYCOLLECTIONFROMWKB, 0) +} + +func (s *FunctionNameBaseContext) ST_GEOMETRYFROMTEXT() antlr.TerminalNode { + return s.GetToken(MySqlParserST_GEOMETRYFROMTEXT, 0) +} + +func (s *FunctionNameBaseContext) ST_GEOMETRYFROMWKB() antlr.TerminalNode { + return s.GetToken(MySqlParserST_GEOMETRYFROMWKB, 0) +} + +func (s *FunctionNameBaseContext) ST_GEOMETRYN() antlr.TerminalNode { + return s.GetToken(MySqlParserST_GEOMETRYN, 0) +} + +func (s *FunctionNameBaseContext) ST_GEOMETRYTYPE() antlr.TerminalNode { + return s.GetToken(MySqlParserST_GEOMETRYTYPE, 0) +} + +func (s *FunctionNameBaseContext) ST_GEOMFROMTEXT() antlr.TerminalNode { + return s.GetToken(MySqlParserST_GEOMFROMTEXT, 0) +} + +func (s *FunctionNameBaseContext) ST_GEOMFROMWKB() antlr.TerminalNode { + return s.GetToken(MySqlParserST_GEOMFROMWKB, 0) +} + +func (s *FunctionNameBaseContext) ST_INTERIORRINGN() antlr.TerminalNode { + return s.GetToken(MySqlParserST_INTERIORRINGN, 0) +} + +func (s *FunctionNameBaseContext) ST_INTERSECTION() antlr.TerminalNode { + return s.GetToken(MySqlParserST_INTERSECTION, 0) +} + +func (s *FunctionNameBaseContext) ST_INTERSECTS() antlr.TerminalNode { + return s.GetToken(MySqlParserST_INTERSECTS, 0) +} + +func (s *FunctionNameBaseContext) ST_ISCLOSED() antlr.TerminalNode { + return s.GetToken(MySqlParserST_ISCLOSED, 0) +} + +func (s *FunctionNameBaseContext) ST_ISEMPTY() antlr.TerminalNode { + return s.GetToken(MySqlParserST_ISEMPTY, 0) +} + +func (s *FunctionNameBaseContext) ST_ISSIMPLE() antlr.TerminalNode { + return s.GetToken(MySqlParserST_ISSIMPLE, 0) +} + +func (s *FunctionNameBaseContext) ST_LINEFROMTEXT() antlr.TerminalNode { + return s.GetToken(MySqlParserST_LINEFROMTEXT, 0) +} + +func (s *FunctionNameBaseContext) ST_LINEFROMWKB() antlr.TerminalNode { + return s.GetToken(MySqlParserST_LINEFROMWKB, 0) +} + +func (s *FunctionNameBaseContext) ST_LINESTRINGFROMTEXT() antlr.TerminalNode { + return s.GetToken(MySqlParserST_LINESTRINGFROMTEXT, 0) +} + +func (s *FunctionNameBaseContext) ST_LINESTRINGFROMWKB() antlr.TerminalNode { + return s.GetToken(MySqlParserST_LINESTRINGFROMWKB, 0) +} + +func (s *FunctionNameBaseContext) ST_NUMGEOMETRIES() antlr.TerminalNode { + return s.GetToken(MySqlParserST_NUMGEOMETRIES, 0) +} + +func (s *FunctionNameBaseContext) ST_NUMINTERIORRING() antlr.TerminalNode { + return s.GetToken(MySqlParserST_NUMINTERIORRING, 0) +} + +func (s *FunctionNameBaseContext) ST_NUMINTERIORRINGS() antlr.TerminalNode { + return s.GetToken(MySqlParserST_NUMINTERIORRINGS, 0) +} + +func (s *FunctionNameBaseContext) ST_NUMPOINTS() antlr.TerminalNode { + return s.GetToken(MySqlParserST_NUMPOINTS, 0) +} + +func (s *FunctionNameBaseContext) ST_OVERLAPS() antlr.TerminalNode { + return s.GetToken(MySqlParserST_OVERLAPS, 0) +} + +func (s *FunctionNameBaseContext) ST_POINTFROMTEXT() antlr.TerminalNode { + return s.GetToken(MySqlParserST_POINTFROMTEXT, 0) +} + +func (s *FunctionNameBaseContext) ST_POINTFROMWKB() antlr.TerminalNode { + return s.GetToken(MySqlParserST_POINTFROMWKB, 0) +} + +func (s *FunctionNameBaseContext) ST_POINTN() antlr.TerminalNode { + return s.GetToken(MySqlParserST_POINTN, 0) +} + +func (s *FunctionNameBaseContext) ST_POLYFROMTEXT() antlr.TerminalNode { + return s.GetToken(MySqlParserST_POLYFROMTEXT, 0) +} + +func (s *FunctionNameBaseContext) ST_POLYFROMWKB() antlr.TerminalNode { + return s.GetToken(MySqlParserST_POLYFROMWKB, 0) +} + +func (s *FunctionNameBaseContext) ST_POLYGONFROMTEXT() antlr.TerminalNode { + return s.GetToken(MySqlParserST_POLYGONFROMTEXT, 0) +} + +func (s *FunctionNameBaseContext) ST_POLYGONFROMWKB() antlr.TerminalNode { + return s.GetToken(MySqlParserST_POLYGONFROMWKB, 0) +} + +func (s *FunctionNameBaseContext) ST_SRID() antlr.TerminalNode { + return s.GetToken(MySqlParserST_SRID, 0) +} + +func (s *FunctionNameBaseContext) ST_STARTPOINT() antlr.TerminalNode { + return s.GetToken(MySqlParserST_STARTPOINT, 0) +} + +func (s *FunctionNameBaseContext) ST_SYMDIFFERENCE() antlr.TerminalNode { + return s.GetToken(MySqlParserST_SYMDIFFERENCE, 0) +} + +func (s *FunctionNameBaseContext) ST_TOUCHES() antlr.TerminalNode { + return s.GetToken(MySqlParserST_TOUCHES, 0) +} + +func (s *FunctionNameBaseContext) ST_UNION() antlr.TerminalNode { + return s.GetToken(MySqlParserST_UNION, 0) +} + +func (s *FunctionNameBaseContext) ST_WITHIN() antlr.TerminalNode { + return s.GetToken(MySqlParserST_WITHIN, 0) +} + +func (s *FunctionNameBaseContext) ST_X() antlr.TerminalNode { + return s.GetToken(MySqlParserST_X, 0) +} + +func (s *FunctionNameBaseContext) ST_Y() antlr.TerminalNode { + return s.GetToken(MySqlParserST_Y, 0) +} + +func (s *FunctionNameBaseContext) STRING_TO_VECTOR() antlr.TerminalNode { + return s.GetToken(MySqlParserSTRING_TO_VECTOR, 0) +} + +func (s *FunctionNameBaseContext) SUBDATE() antlr.TerminalNode { + return s.GetToken(MySqlParserSUBDATE, 0) +} + +func (s *FunctionNameBaseContext) SUBSTRING_INDEX() antlr.TerminalNode { + return s.GetToken(MySqlParserSUBSTRING_INDEX, 0) +} + +func (s *FunctionNameBaseContext) SUBTIME() antlr.TerminalNode { + return s.GetToken(MySqlParserSUBTIME, 0) +} + +func (s *FunctionNameBaseContext) SYSTEM_USER() antlr.TerminalNode { + return s.GetToken(MySqlParserSYSTEM_USER, 0) +} + +func (s *FunctionNameBaseContext) TAN() antlr.TerminalNode { + return s.GetToken(MySqlParserTAN, 0) +} + +func (s *FunctionNameBaseContext) TIME() antlr.TerminalNode { + return s.GetToken(MySqlParserTIME, 0) +} + +func (s *FunctionNameBaseContext) TIMEDIFF() antlr.TerminalNode { + return s.GetToken(MySqlParserTIMEDIFF, 0) +} + +func (s *FunctionNameBaseContext) TIMESTAMP() antlr.TerminalNode { + return s.GetToken(MySqlParserTIMESTAMP, 0) +} + +func (s *FunctionNameBaseContext) TIMESTAMPADD() antlr.TerminalNode { + return s.GetToken(MySqlParserTIMESTAMPADD, 0) +} + +func (s *FunctionNameBaseContext) TIMESTAMPDIFF() antlr.TerminalNode { + return s.GetToken(MySqlParserTIMESTAMPDIFF, 0) +} + +func (s *FunctionNameBaseContext) TIME_FORMAT() antlr.TerminalNode { + return s.GetToken(MySqlParserTIME_FORMAT, 0) +} + +func (s *FunctionNameBaseContext) TIME_TO_SEC() antlr.TerminalNode { + return s.GetToken(MySqlParserTIME_TO_SEC, 0) +} + +func (s *FunctionNameBaseContext) TOUCHES() antlr.TerminalNode { + return s.GetToken(MySqlParserTOUCHES, 0) +} + +func (s *FunctionNameBaseContext) TO_BASE64() antlr.TerminalNode { + return s.GetToken(MySqlParserTO_BASE64, 0) +} + +func (s *FunctionNameBaseContext) TO_DAYS() antlr.TerminalNode { + return s.GetToken(MySqlParserTO_DAYS, 0) +} + +func (s *FunctionNameBaseContext) TO_SECONDS() antlr.TerminalNode { + return s.GetToken(MySqlParserTO_SECONDS, 0) +} + +func (s *FunctionNameBaseContext) UCASE() antlr.TerminalNode { + return s.GetToken(MySqlParserUCASE, 0) +} + +func (s *FunctionNameBaseContext) UNCOMPRESS() antlr.TerminalNode { + return s.GetToken(MySqlParserUNCOMPRESS, 0) +} + +func (s *FunctionNameBaseContext) UNCOMPRESSED_LENGTH() antlr.TerminalNode { + return s.GetToken(MySqlParserUNCOMPRESSED_LENGTH, 0) +} + +func (s *FunctionNameBaseContext) UNHEX() antlr.TerminalNode { + return s.GetToken(MySqlParserUNHEX, 0) +} + +func (s *FunctionNameBaseContext) UNIX_TIMESTAMP() antlr.TerminalNode { + return s.GetToken(MySqlParserUNIX_TIMESTAMP, 0) +} + +func (s *FunctionNameBaseContext) UPDATEXML() antlr.TerminalNode { + return s.GetToken(MySqlParserUPDATEXML, 0) +} + +func (s *FunctionNameBaseContext) UPPER() antlr.TerminalNode { + return s.GetToken(MySqlParserUPPER, 0) +} + +func (s *FunctionNameBaseContext) UUID() antlr.TerminalNode { + return s.GetToken(MySqlParserUUID, 0) +} + +func (s *FunctionNameBaseContext) UUID_SHORT() antlr.TerminalNode { + return s.GetToken(MySqlParserUUID_SHORT, 0) +} + +func (s *FunctionNameBaseContext) VALIDATE_PASSWORD_STRENGTH() antlr.TerminalNode { + return s.GetToken(MySqlParserVALIDATE_PASSWORD_STRENGTH, 0) +} + +func (s *FunctionNameBaseContext) VECTOR_DIM() antlr.TerminalNode { + return s.GetToken(MySqlParserVECTOR_DIM, 0) +} + +func (s *FunctionNameBaseContext) VECTOR_TO_STRING() antlr.TerminalNode { + return s.GetToken(MySqlParserVECTOR_TO_STRING, 0) +} + +func (s *FunctionNameBaseContext) VERSION() antlr.TerminalNode { + return s.GetToken(MySqlParserVERSION, 0) +} + +func (s *FunctionNameBaseContext) VISIBLE() antlr.TerminalNode { + return s.GetToken(MySqlParserVISIBLE, 0) +} + +func (s *FunctionNameBaseContext) WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS() antlr.TerminalNode { + return s.GetToken(MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS, 0) +} + +func (s *FunctionNameBaseContext) WEEK() antlr.TerminalNode { + return s.GetToken(MySqlParserWEEK, 0) +} + +func (s *FunctionNameBaseContext) WEEKDAY() antlr.TerminalNode { + return s.GetToken(MySqlParserWEEKDAY, 0) +} + +func (s *FunctionNameBaseContext) WEEKOFYEAR() antlr.TerminalNode { + return s.GetToken(MySqlParserWEEKOFYEAR, 0) +} + +func (s *FunctionNameBaseContext) WEIGHT_STRING() antlr.TerminalNode { + return s.GetToken(MySqlParserWEIGHT_STRING, 0) +} + +func (s *FunctionNameBaseContext) WITHIN() antlr.TerminalNode { + return s.GetToken(MySqlParserWITHIN, 0) +} + +func (s *FunctionNameBaseContext) YEAR() antlr.TerminalNode { + return s.GetToken(MySqlParserYEAR, 0) +} + +func (s *FunctionNameBaseContext) YEARWEEK() antlr.TerminalNode { + return s.GetToken(MySqlParserYEARWEEK, 0) +} + +func (s *FunctionNameBaseContext) Y_FUNCTION() antlr.TerminalNode { + return s.GetToken(MySqlParserY_FUNCTION, 0) +} + +func (s *FunctionNameBaseContext) X_FUNCTION() antlr.TerminalNode { + return s.GetToken(MySqlParserX_FUNCTION, 0) +} + +func (s *FunctionNameBaseContext) JSON_ARRAY() antlr.TerminalNode { + return s.GetToken(MySqlParserJSON_ARRAY, 0) +} + +func (s *FunctionNameBaseContext) JSON_OBJECT() antlr.TerminalNode { + return s.GetToken(MySqlParserJSON_OBJECT, 0) +} + +func (s *FunctionNameBaseContext) JSON_QUOTE() antlr.TerminalNode { + return s.GetToken(MySqlParserJSON_QUOTE, 0) +} + +func (s *FunctionNameBaseContext) JSON_CONTAINS() antlr.TerminalNode { + return s.GetToken(MySqlParserJSON_CONTAINS, 0) +} + +func (s *FunctionNameBaseContext) JSON_CONTAINS_PATH() antlr.TerminalNode { + return s.GetToken(MySqlParserJSON_CONTAINS_PATH, 0) +} + +func (s *FunctionNameBaseContext) JSON_EXTRACT() antlr.TerminalNode { + return s.GetToken(MySqlParserJSON_EXTRACT, 0) +} + +func (s *FunctionNameBaseContext) JSON_KEYS() antlr.TerminalNode { + return s.GetToken(MySqlParserJSON_KEYS, 0) +} + +func (s *FunctionNameBaseContext) JSON_OVERLAPS() antlr.TerminalNode { + return s.GetToken(MySqlParserJSON_OVERLAPS, 0) +} + +func (s *FunctionNameBaseContext) JSON_SEARCH() antlr.TerminalNode { + return s.GetToken(MySqlParserJSON_SEARCH, 0) +} + +func (s *FunctionNameBaseContext) JSON_VALUE() antlr.TerminalNode { + return s.GetToken(MySqlParserJSON_VALUE, 0) +} + +func (s *FunctionNameBaseContext) JSON_ARRAY_APPEND() antlr.TerminalNode { + return s.GetToken(MySqlParserJSON_ARRAY_APPEND, 0) +} + +func (s *FunctionNameBaseContext) JSON_ARRAY_INSERT() antlr.TerminalNode { + return s.GetToken(MySqlParserJSON_ARRAY_INSERT, 0) +} + +func (s *FunctionNameBaseContext) JSON_INSERT() antlr.TerminalNode { + return s.GetToken(MySqlParserJSON_INSERT, 0) +} + +func (s *FunctionNameBaseContext) JSON_MERGE() antlr.TerminalNode { + return s.GetToken(MySqlParserJSON_MERGE, 0) +} + +func (s *FunctionNameBaseContext) JSON_MERGE_PATCH() antlr.TerminalNode { + return s.GetToken(MySqlParserJSON_MERGE_PATCH, 0) +} + +func (s *FunctionNameBaseContext) JSON_MERGE_PRESERVE() antlr.TerminalNode { + return s.GetToken(MySqlParserJSON_MERGE_PRESERVE, 0) +} + +func (s *FunctionNameBaseContext) JSON_REMOVE() antlr.TerminalNode { + return s.GetToken(MySqlParserJSON_REMOVE, 0) +} + +func (s *FunctionNameBaseContext) JSON_REPLACE() antlr.TerminalNode { + return s.GetToken(MySqlParserJSON_REPLACE, 0) +} + +func (s *FunctionNameBaseContext) JSON_SET() antlr.TerminalNode { + return s.GetToken(MySqlParserJSON_SET, 0) +} + +func (s *FunctionNameBaseContext) JSON_UNQUOTE() antlr.TerminalNode { + return s.GetToken(MySqlParserJSON_UNQUOTE, 0) +} + +func (s *FunctionNameBaseContext) JSON_DEPTH() antlr.TerminalNode { + return s.GetToken(MySqlParserJSON_DEPTH, 0) +} + +func (s *FunctionNameBaseContext) JSON_LENGTH() antlr.TerminalNode { + return s.GetToken(MySqlParserJSON_LENGTH, 0) +} + +func (s *FunctionNameBaseContext) JSON_TYPE() antlr.TerminalNode { + return s.GetToken(MySqlParserJSON_TYPE, 0) +} + +func (s *FunctionNameBaseContext) JSON_VALID() antlr.TerminalNode { + return s.GetToken(MySqlParserJSON_VALID, 0) +} + +func (s *FunctionNameBaseContext) JSON_TABLE() antlr.TerminalNode { + return s.GetToken(MySqlParserJSON_TABLE, 0) +} + +func (s *FunctionNameBaseContext) JSON_SCHEMA_VALID() antlr.TerminalNode { + return s.GetToken(MySqlParserJSON_SCHEMA_VALID, 0) +} + +func (s *FunctionNameBaseContext) JSON_SCHEMA_VALIDATION_REPORT() antlr.TerminalNode { + return s.GetToken(MySqlParserJSON_SCHEMA_VALIDATION_REPORT, 0) +} + +func (s *FunctionNameBaseContext) JSON_PRETTY() antlr.TerminalNode { + return s.GetToken(MySqlParserJSON_PRETTY, 0) +} + +func (s *FunctionNameBaseContext) JSON_STORAGE_FREE() antlr.TerminalNode { + return s.GetToken(MySqlParserJSON_STORAGE_FREE, 0) +} + +func (s *FunctionNameBaseContext) JSON_STORAGE_SIZE() antlr.TerminalNode { + return s.GetToken(MySqlParserJSON_STORAGE_SIZE, 0) +} + +func (s *FunctionNameBaseContext) JSON_ARRAYAGG() antlr.TerminalNode { + return s.GetToken(MySqlParserJSON_ARRAYAGG, 0) +} + +func (s *FunctionNameBaseContext) JSON_OBJECTAGG() antlr.TerminalNode { + return s.GetToken(MySqlParserJSON_OBJECTAGG, 0) +} + +func (s *FunctionNameBaseContext) STATEMENT() antlr.TerminalNode { + return s.GetToken(MySqlParserSTATEMENT, 0) +} + +func (s *FunctionNameBaseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FunctionNameBaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FunctionNameBaseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.EnterFunctionNameBase(s) + } +} + +func (s *FunctionNameBaseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MySqlParserListener); ok { + listenerT.ExitFunctionNameBase(s) + } +} + +func (p *MySqlParser) FunctionNameBase() (localctx IFunctionNameBaseContext) { + localctx = NewFunctionNameBaseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 720, MySqlParserRULE_functionNameBase) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7475) + _la = p.GetTokenStream().LA(1) + + if !(_la == MySqlParserDATABASE || _la == MySqlParserLEFT || ((int64((_la-148)) & ^0x3f) == 0 && ((int64(1)<<(_la-148))&4194309) != 0) || ((int64((_la-217)) & ^0x3f) == 0 && ((int64(1)<<(_la-217))&-34359738345) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&17592218795015) != 0) || _la == MySqlParserINVISIBLE || ((int64((_la-674)) & ^0x3f) == 0 && ((int64(1)<<(_la-674))&-9223372036838064127) != 0) || ((int64((_la-804)) & ^0x3f) == 0 && ((int64(1)<<(_la-804))&-8589934599) != 0) || ((int64((_la-868)) & ^0x3f) == 0 && ((int64(1)<<(_la-868))&-513) != 0) || ((int64((_la-932)) & ^0x3f) == 0 && ((int64(1)<<(_la-932))&-1) != 0) || ((int64((_la-996)) & ^0x3f) == 0 && ((int64(1)<<(_la-996))&-2113) != 0) || ((int64((_la-1060)) & ^0x3f) == 0 && ((int64(1)<<(_la-1060))&9007197107257343) != 0) || _la == MySqlParserMOD) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +func (p *MySqlParser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool { + switch ruleIndex { + case 344: + var t *ExpressionContext = nil + if localctx != nil { + t = localctx.(*ExpressionContext) + } + return p.Expression_Sempred(t, predIndex) + + case 345: + var t *PredicateContext = nil + if localctx != nil { + t = localctx.(*PredicateContext) + } + return p.Predicate_Sempred(t, predIndex) + + case 346: + var t *ExpressionAtomContext = nil + if localctx != nil { + t = localctx.(*ExpressionAtomContext) + } + return p.ExpressionAtom_Sempred(t, predIndex) + + default: + panic("No predicate with index: " + fmt.Sprint(ruleIndex)) + } +} + +func (p *MySqlParser) Expression_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 0: + return p.Precpred(p.GetParserRuleContext(), 3) + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *MySqlParser) Predicate_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 1: + return p.Precpred(p.GetParserRuleContext(), 8) + + case 2: + return p.Precpred(p.GetParserRuleContext(), 6) + + case 3: + return p.Precpred(p.GetParserRuleContext(), 5) + + case 4: + return p.Precpred(p.GetParserRuleContext(), 3) + + case 5: + return p.Precpred(p.GetParserRuleContext(), 10) + + case 6: + return p.Precpred(p.GetParserRuleContext(), 9) + + case 7: + return p.Precpred(p.GetParserRuleContext(), 7) + + case 8: + return p.Precpred(p.GetParserRuleContext(), 4) + + case 9: + return p.Precpred(p.GetParserRuleContext(), 2) + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *MySqlParser) ExpressionAtom_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 10: + return p.Precpred(p.GetParserRuleContext(), 4) + + case 11: + return p.Precpred(p.GetParserRuleContext(), 3) + + case 12: + return p.Precpred(p.GetParserRuleContext(), 2) + + case 13: + return p.Precpred(p.GetParserRuleContext(), 1) + + case 14: + return p.Precpred(p.GetParserRuleContext(), 14) + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} diff --git a/lib/antlr/generated/mysqlparser_base_listener.go b/lib/antlr/generated/mysqlparser_base_listener.go new file mode 100644 index 00000000..0b0174eb --- /dev/null +++ b/lib/antlr/generated/mysqlparser_base_listener.go @@ -0,0 +1,3863 @@ +// Code generated from MySqlParser.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package generated // MySqlParser +import "github.com/antlr4-go/antlr/v4" + +// BaseMySqlParserListener is a complete listener for a parse tree produced by MySqlParser. +type BaseMySqlParserListener struct{} + +var _ MySqlParserListener = &BaseMySqlParserListener{} + +// VisitTerminal is called when a terminal node is visited. +func (s *BaseMySqlParserListener) VisitTerminal(node antlr.TerminalNode) {} + +// VisitErrorNode is called when an error node is visited. +func (s *BaseMySqlParserListener) VisitErrorNode(node antlr.ErrorNode) {} + +// EnterEveryRule is called when any rule is entered. +func (s *BaseMySqlParserListener) EnterEveryRule(ctx antlr.ParserRuleContext) {} + +// ExitEveryRule is called when any rule is exited. +func (s *BaseMySqlParserListener) ExitEveryRule(ctx antlr.ParserRuleContext) {} + +// EnterRoot is called when production root is entered. +func (s *BaseMySqlParserListener) EnterRoot(ctx *RootContext) {} + +// ExitRoot is called when production root is exited. +func (s *BaseMySqlParserListener) ExitRoot(ctx *RootContext) {} + +// EnterSqlStatements is called when production sqlStatements is entered. +func (s *BaseMySqlParserListener) EnterSqlStatements(ctx *SqlStatementsContext) {} + +// ExitSqlStatements is called when production sqlStatements is exited. +func (s *BaseMySqlParserListener) ExitSqlStatements(ctx *SqlStatementsContext) {} + +// EnterSqlStatement is called when production sqlStatement is entered. +func (s *BaseMySqlParserListener) EnterSqlStatement(ctx *SqlStatementContext) {} + +// ExitSqlStatement is called when production sqlStatement is exited. +func (s *BaseMySqlParserListener) ExitSqlStatement(ctx *SqlStatementContext) {} + +// EnterEmptyStatement_ is called when production emptyStatement_ is entered. +func (s *BaseMySqlParserListener) EnterEmptyStatement_(ctx *EmptyStatement_Context) {} + +// ExitEmptyStatement_ is called when production emptyStatement_ is exited. +func (s *BaseMySqlParserListener) ExitEmptyStatement_(ctx *EmptyStatement_Context) {} + +// EnterDdlStatement is called when production ddlStatement is entered. +func (s *BaseMySqlParserListener) EnterDdlStatement(ctx *DdlStatementContext) {} + +// ExitDdlStatement is called when production ddlStatement is exited. +func (s *BaseMySqlParserListener) ExitDdlStatement(ctx *DdlStatementContext) {} + +// EnterDmlStatement is called when production dmlStatement is entered. +func (s *BaseMySqlParserListener) EnterDmlStatement(ctx *DmlStatementContext) {} + +// ExitDmlStatement is called when production dmlStatement is exited. +func (s *BaseMySqlParserListener) ExitDmlStatement(ctx *DmlStatementContext) {} + +// EnterTransactionStatement is called when production transactionStatement is entered. +func (s *BaseMySqlParserListener) EnterTransactionStatement(ctx *TransactionStatementContext) {} + +// ExitTransactionStatement is called when production transactionStatement is exited. +func (s *BaseMySqlParserListener) ExitTransactionStatement(ctx *TransactionStatementContext) {} + +// EnterReplicationStatement is called when production replicationStatement is entered. +func (s *BaseMySqlParserListener) EnterReplicationStatement(ctx *ReplicationStatementContext) {} + +// ExitReplicationStatement is called when production replicationStatement is exited. +func (s *BaseMySqlParserListener) ExitReplicationStatement(ctx *ReplicationStatementContext) {} + +// EnterPreparedStatement is called when production preparedStatement is entered. +func (s *BaseMySqlParserListener) EnterPreparedStatement(ctx *PreparedStatementContext) {} + +// ExitPreparedStatement is called when production preparedStatement is exited. +func (s *BaseMySqlParserListener) ExitPreparedStatement(ctx *PreparedStatementContext) {} + +// EnterCompoundStatement is called when production compoundStatement is entered. +func (s *BaseMySqlParserListener) EnterCompoundStatement(ctx *CompoundStatementContext) {} + +// ExitCompoundStatement is called when production compoundStatement is exited. +func (s *BaseMySqlParserListener) ExitCompoundStatement(ctx *CompoundStatementContext) {} + +// EnterAdministrationStatement is called when production administrationStatement is entered. +func (s *BaseMySqlParserListener) EnterAdministrationStatement(ctx *AdministrationStatementContext) {} + +// ExitAdministrationStatement is called when production administrationStatement is exited. +func (s *BaseMySqlParserListener) ExitAdministrationStatement(ctx *AdministrationStatementContext) {} + +// EnterUtilityStatement is called when production utilityStatement is entered. +func (s *BaseMySqlParserListener) EnterUtilityStatement(ctx *UtilityStatementContext) {} + +// ExitUtilityStatement is called when production utilityStatement is exited. +func (s *BaseMySqlParserListener) ExitUtilityStatement(ctx *UtilityStatementContext) {} + +// EnterCreateDatabase is called when production createDatabase is entered. +func (s *BaseMySqlParserListener) EnterCreateDatabase(ctx *CreateDatabaseContext) {} + +// ExitCreateDatabase is called when production createDatabase is exited. +func (s *BaseMySqlParserListener) ExitCreateDatabase(ctx *CreateDatabaseContext) {} + +// EnterCreateEvent is called when production createEvent is entered. +func (s *BaseMySqlParserListener) EnterCreateEvent(ctx *CreateEventContext) {} + +// ExitCreateEvent is called when production createEvent is exited. +func (s *BaseMySqlParserListener) ExitCreateEvent(ctx *CreateEventContext) {} + +// EnterCreateIndex is called when production createIndex is entered. +func (s *BaseMySqlParserListener) EnterCreateIndex(ctx *CreateIndexContext) {} + +// ExitCreateIndex is called when production createIndex is exited. +func (s *BaseMySqlParserListener) ExitCreateIndex(ctx *CreateIndexContext) {} + +// EnterCreateLogfileGroup is called when production createLogfileGroup is entered. +func (s *BaseMySqlParserListener) EnterCreateLogfileGroup(ctx *CreateLogfileGroupContext) {} + +// ExitCreateLogfileGroup is called when production createLogfileGroup is exited. +func (s *BaseMySqlParserListener) ExitCreateLogfileGroup(ctx *CreateLogfileGroupContext) {} + +// EnterCreateProcedure is called when production createProcedure is entered. +func (s *BaseMySqlParserListener) EnterCreateProcedure(ctx *CreateProcedureContext) {} + +// ExitCreateProcedure is called when production createProcedure is exited. +func (s *BaseMySqlParserListener) ExitCreateProcedure(ctx *CreateProcedureContext) {} + +// EnterCreateFunction is called when production createFunction is entered. +func (s *BaseMySqlParserListener) EnterCreateFunction(ctx *CreateFunctionContext) {} + +// ExitCreateFunction is called when production createFunction is exited. +func (s *BaseMySqlParserListener) ExitCreateFunction(ctx *CreateFunctionContext) {} + +// EnterCreateRole is called when production createRole is entered. +func (s *BaseMySqlParserListener) EnterCreateRole(ctx *CreateRoleContext) {} + +// ExitCreateRole is called when production createRole is exited. +func (s *BaseMySqlParserListener) ExitCreateRole(ctx *CreateRoleContext) {} + +// EnterCreateServer is called when production createServer is entered. +func (s *BaseMySqlParserListener) EnterCreateServer(ctx *CreateServerContext) {} + +// ExitCreateServer is called when production createServer is exited. +func (s *BaseMySqlParserListener) ExitCreateServer(ctx *CreateServerContext) {} + +// EnterCopyCreateTable is called when production copyCreateTable is entered. +func (s *BaseMySqlParserListener) EnterCopyCreateTable(ctx *CopyCreateTableContext) {} + +// ExitCopyCreateTable is called when production copyCreateTable is exited. +func (s *BaseMySqlParserListener) ExitCopyCreateTable(ctx *CopyCreateTableContext) {} + +// EnterQueryCreateTable is called when production queryCreateTable is entered. +func (s *BaseMySqlParserListener) EnterQueryCreateTable(ctx *QueryCreateTableContext) {} + +// ExitQueryCreateTable is called when production queryCreateTable is exited. +func (s *BaseMySqlParserListener) ExitQueryCreateTable(ctx *QueryCreateTableContext) {} + +// EnterColumnCreateTable is called when production columnCreateTable is entered. +func (s *BaseMySqlParserListener) EnterColumnCreateTable(ctx *ColumnCreateTableContext) {} + +// ExitColumnCreateTable is called when production columnCreateTable is exited. +func (s *BaseMySqlParserListener) ExitColumnCreateTable(ctx *ColumnCreateTableContext) {} + +// EnterCreateTablespaceInnodb is called when production createTablespaceInnodb is entered. +func (s *BaseMySqlParserListener) EnterCreateTablespaceInnodb(ctx *CreateTablespaceInnodbContext) {} + +// ExitCreateTablespaceInnodb is called when production createTablespaceInnodb is exited. +func (s *BaseMySqlParserListener) ExitCreateTablespaceInnodb(ctx *CreateTablespaceInnodbContext) {} + +// EnterCreateTablespaceNdb is called when production createTablespaceNdb is entered. +func (s *BaseMySqlParserListener) EnterCreateTablespaceNdb(ctx *CreateTablespaceNdbContext) {} + +// ExitCreateTablespaceNdb is called when production createTablespaceNdb is exited. +func (s *BaseMySqlParserListener) ExitCreateTablespaceNdb(ctx *CreateTablespaceNdbContext) {} + +// EnterCreateTrigger is called when production createTrigger is entered. +func (s *BaseMySqlParserListener) EnterCreateTrigger(ctx *CreateTriggerContext) {} + +// ExitCreateTrigger is called when production createTrigger is exited. +func (s *BaseMySqlParserListener) ExitCreateTrigger(ctx *CreateTriggerContext) {} + +// EnterWithClause is called when production withClause is entered. +func (s *BaseMySqlParserListener) EnterWithClause(ctx *WithClauseContext) {} + +// ExitWithClause is called when production withClause is exited. +func (s *BaseMySqlParserListener) ExitWithClause(ctx *WithClauseContext) {} + +// EnterCommonTableExpressions is called when production commonTableExpressions is entered. +func (s *BaseMySqlParserListener) EnterCommonTableExpressions(ctx *CommonTableExpressionsContext) {} + +// ExitCommonTableExpressions is called when production commonTableExpressions is exited. +func (s *BaseMySqlParserListener) ExitCommonTableExpressions(ctx *CommonTableExpressionsContext) {} + +// EnterCteName is called when production cteName is entered. +func (s *BaseMySqlParserListener) EnterCteName(ctx *CteNameContext) {} + +// ExitCteName is called when production cteName is exited. +func (s *BaseMySqlParserListener) ExitCteName(ctx *CteNameContext) {} + +// EnterCteColumnName is called when production cteColumnName is entered. +func (s *BaseMySqlParserListener) EnterCteColumnName(ctx *CteColumnNameContext) {} + +// ExitCteColumnName is called when production cteColumnName is exited. +func (s *BaseMySqlParserListener) ExitCteColumnName(ctx *CteColumnNameContext) {} + +// EnterCreateView is called when production createView is entered. +func (s *BaseMySqlParserListener) EnterCreateView(ctx *CreateViewContext) {} + +// ExitCreateView is called when production createView is exited. +func (s *BaseMySqlParserListener) ExitCreateView(ctx *CreateViewContext) {} + +// EnterCreateDatabaseOption is called when production createDatabaseOption is entered. +func (s *BaseMySqlParserListener) EnterCreateDatabaseOption(ctx *CreateDatabaseOptionContext) {} + +// ExitCreateDatabaseOption is called when production createDatabaseOption is exited. +func (s *BaseMySqlParserListener) ExitCreateDatabaseOption(ctx *CreateDatabaseOptionContext) {} + +// EnterCharSet is called when production charSet is entered. +func (s *BaseMySqlParserListener) EnterCharSet(ctx *CharSetContext) {} + +// ExitCharSet is called when production charSet is exited. +func (s *BaseMySqlParserListener) ExitCharSet(ctx *CharSetContext) {} + +// EnterCurrentUserExpression is called when production currentUserExpression is entered. +func (s *BaseMySqlParserListener) EnterCurrentUserExpression(ctx *CurrentUserExpressionContext) {} + +// ExitCurrentUserExpression is called when production currentUserExpression is exited. +func (s *BaseMySqlParserListener) ExitCurrentUserExpression(ctx *CurrentUserExpressionContext) {} + +// EnterOwnerStatement is called when production ownerStatement is entered. +func (s *BaseMySqlParserListener) EnterOwnerStatement(ctx *OwnerStatementContext) {} + +// ExitOwnerStatement is called when production ownerStatement is exited. +func (s *BaseMySqlParserListener) ExitOwnerStatement(ctx *OwnerStatementContext) {} + +// EnterPreciseSchedule is called when production preciseSchedule is entered. +func (s *BaseMySqlParserListener) EnterPreciseSchedule(ctx *PreciseScheduleContext) {} + +// ExitPreciseSchedule is called when production preciseSchedule is exited. +func (s *BaseMySqlParserListener) ExitPreciseSchedule(ctx *PreciseScheduleContext) {} + +// EnterIntervalSchedule is called when production intervalSchedule is entered. +func (s *BaseMySqlParserListener) EnterIntervalSchedule(ctx *IntervalScheduleContext) {} + +// ExitIntervalSchedule is called when production intervalSchedule is exited. +func (s *BaseMySqlParserListener) ExitIntervalSchedule(ctx *IntervalScheduleContext) {} + +// EnterTimestampValue is called when production timestampValue is entered. +func (s *BaseMySqlParserListener) EnterTimestampValue(ctx *TimestampValueContext) {} + +// ExitTimestampValue is called when production timestampValue is exited. +func (s *BaseMySqlParserListener) ExitTimestampValue(ctx *TimestampValueContext) {} + +// EnterIntervalExpr is called when production intervalExpr is entered. +func (s *BaseMySqlParserListener) EnterIntervalExpr(ctx *IntervalExprContext) {} + +// ExitIntervalExpr is called when production intervalExpr is exited. +func (s *BaseMySqlParserListener) ExitIntervalExpr(ctx *IntervalExprContext) {} + +// EnterIntervalType is called when production intervalType is entered. +func (s *BaseMySqlParserListener) EnterIntervalType(ctx *IntervalTypeContext) {} + +// ExitIntervalType is called when production intervalType is exited. +func (s *BaseMySqlParserListener) ExitIntervalType(ctx *IntervalTypeContext) {} + +// EnterEnableType is called when production enableType is entered. +func (s *BaseMySqlParserListener) EnterEnableType(ctx *EnableTypeContext) {} + +// ExitEnableType is called when production enableType is exited. +func (s *BaseMySqlParserListener) ExitEnableType(ctx *EnableTypeContext) {} + +// EnterIndexType is called when production indexType is entered. +func (s *BaseMySqlParserListener) EnterIndexType(ctx *IndexTypeContext) {} + +// ExitIndexType is called when production indexType is exited. +func (s *BaseMySqlParserListener) ExitIndexType(ctx *IndexTypeContext) {} + +// EnterIndexOption is called when production indexOption is entered. +func (s *BaseMySqlParserListener) EnterIndexOption(ctx *IndexOptionContext) {} + +// ExitIndexOption is called when production indexOption is exited. +func (s *BaseMySqlParserListener) ExitIndexOption(ctx *IndexOptionContext) {} + +// EnterProcedureParameter is called when production procedureParameter is entered. +func (s *BaseMySqlParserListener) EnterProcedureParameter(ctx *ProcedureParameterContext) {} + +// ExitProcedureParameter is called when production procedureParameter is exited. +func (s *BaseMySqlParserListener) ExitProcedureParameter(ctx *ProcedureParameterContext) {} + +// EnterFunctionParameter is called when production functionParameter is entered. +func (s *BaseMySqlParserListener) EnterFunctionParameter(ctx *FunctionParameterContext) {} + +// ExitFunctionParameter is called when production functionParameter is exited. +func (s *BaseMySqlParserListener) ExitFunctionParameter(ctx *FunctionParameterContext) {} + +// EnterRoutineComment is called when production routineComment is entered. +func (s *BaseMySqlParserListener) EnterRoutineComment(ctx *RoutineCommentContext) {} + +// ExitRoutineComment is called when production routineComment is exited. +func (s *BaseMySqlParserListener) ExitRoutineComment(ctx *RoutineCommentContext) {} + +// EnterRoutineLanguage is called when production routineLanguage is entered. +func (s *BaseMySqlParserListener) EnterRoutineLanguage(ctx *RoutineLanguageContext) {} + +// ExitRoutineLanguage is called when production routineLanguage is exited. +func (s *BaseMySqlParserListener) ExitRoutineLanguage(ctx *RoutineLanguageContext) {} + +// EnterRoutineBehavior is called when production routineBehavior is entered. +func (s *BaseMySqlParserListener) EnterRoutineBehavior(ctx *RoutineBehaviorContext) {} + +// ExitRoutineBehavior is called when production routineBehavior is exited. +func (s *BaseMySqlParserListener) ExitRoutineBehavior(ctx *RoutineBehaviorContext) {} + +// EnterRoutineData is called when production routineData is entered. +func (s *BaseMySqlParserListener) EnterRoutineData(ctx *RoutineDataContext) {} + +// ExitRoutineData is called when production routineData is exited. +func (s *BaseMySqlParserListener) ExitRoutineData(ctx *RoutineDataContext) {} + +// EnterRoutineSecurity is called when production routineSecurity is entered. +func (s *BaseMySqlParserListener) EnterRoutineSecurity(ctx *RoutineSecurityContext) {} + +// ExitRoutineSecurity is called when production routineSecurity is exited. +func (s *BaseMySqlParserListener) ExitRoutineSecurity(ctx *RoutineSecurityContext) {} + +// EnterServerOption is called when production serverOption is entered. +func (s *BaseMySqlParserListener) EnterServerOption(ctx *ServerOptionContext) {} + +// ExitServerOption is called when production serverOption is exited. +func (s *BaseMySqlParserListener) ExitServerOption(ctx *ServerOptionContext) {} + +// EnterCreateDefinitions is called when production createDefinitions is entered. +func (s *BaseMySqlParserListener) EnterCreateDefinitions(ctx *CreateDefinitionsContext) {} + +// ExitCreateDefinitions is called when production createDefinitions is exited. +func (s *BaseMySqlParserListener) ExitCreateDefinitions(ctx *CreateDefinitionsContext) {} + +// EnterColumnDeclaration is called when production columnDeclaration is entered. +func (s *BaseMySqlParserListener) EnterColumnDeclaration(ctx *ColumnDeclarationContext) {} + +// ExitColumnDeclaration is called when production columnDeclaration is exited. +func (s *BaseMySqlParserListener) ExitColumnDeclaration(ctx *ColumnDeclarationContext) {} + +// EnterConstraintDeclaration is called when production constraintDeclaration is entered. +func (s *BaseMySqlParserListener) EnterConstraintDeclaration(ctx *ConstraintDeclarationContext) {} + +// ExitConstraintDeclaration is called when production constraintDeclaration is exited. +func (s *BaseMySqlParserListener) ExitConstraintDeclaration(ctx *ConstraintDeclarationContext) {} + +// EnterIndexDeclaration is called when production indexDeclaration is entered. +func (s *BaseMySqlParserListener) EnterIndexDeclaration(ctx *IndexDeclarationContext) {} + +// ExitIndexDeclaration is called when production indexDeclaration is exited. +func (s *BaseMySqlParserListener) ExitIndexDeclaration(ctx *IndexDeclarationContext) {} + +// EnterColumnDefinition is called when production columnDefinition is entered. +func (s *BaseMySqlParserListener) EnterColumnDefinition(ctx *ColumnDefinitionContext) {} + +// ExitColumnDefinition is called when production columnDefinition is exited. +func (s *BaseMySqlParserListener) ExitColumnDefinition(ctx *ColumnDefinitionContext) {} + +// EnterNullColumnConstraint is called when production nullColumnConstraint is entered. +func (s *BaseMySqlParserListener) EnterNullColumnConstraint(ctx *NullColumnConstraintContext) {} + +// ExitNullColumnConstraint is called when production nullColumnConstraint is exited. +func (s *BaseMySqlParserListener) ExitNullColumnConstraint(ctx *NullColumnConstraintContext) {} + +// EnterDefaultColumnConstraint is called when production defaultColumnConstraint is entered. +func (s *BaseMySqlParserListener) EnterDefaultColumnConstraint(ctx *DefaultColumnConstraintContext) {} + +// ExitDefaultColumnConstraint is called when production defaultColumnConstraint is exited. +func (s *BaseMySqlParserListener) ExitDefaultColumnConstraint(ctx *DefaultColumnConstraintContext) {} + +// EnterVisibilityColumnConstraint is called when production visibilityColumnConstraint is entered. +func (s *BaseMySqlParserListener) EnterVisibilityColumnConstraint(ctx *VisibilityColumnConstraintContext) { +} + +// ExitVisibilityColumnConstraint is called when production visibilityColumnConstraint is exited. +func (s *BaseMySqlParserListener) ExitVisibilityColumnConstraint(ctx *VisibilityColumnConstraintContext) { +} + +// EnterInvisibilityColumnConstraint is called when production invisibilityColumnConstraint is entered. +func (s *BaseMySqlParserListener) EnterInvisibilityColumnConstraint(ctx *InvisibilityColumnConstraintContext) { +} + +// ExitInvisibilityColumnConstraint is called when production invisibilityColumnConstraint is exited. +func (s *BaseMySqlParserListener) ExitInvisibilityColumnConstraint(ctx *InvisibilityColumnConstraintContext) { +} + +// EnterAutoIncrementColumnConstraint is called when production autoIncrementColumnConstraint is entered. +func (s *BaseMySqlParserListener) EnterAutoIncrementColumnConstraint(ctx *AutoIncrementColumnConstraintContext) { +} + +// ExitAutoIncrementColumnConstraint is called when production autoIncrementColumnConstraint is exited. +func (s *BaseMySqlParserListener) ExitAutoIncrementColumnConstraint(ctx *AutoIncrementColumnConstraintContext) { +} + +// EnterPrimaryKeyColumnConstraint is called when production primaryKeyColumnConstraint is entered. +func (s *BaseMySqlParserListener) EnterPrimaryKeyColumnConstraint(ctx *PrimaryKeyColumnConstraintContext) { +} + +// ExitPrimaryKeyColumnConstraint is called when production primaryKeyColumnConstraint is exited. +func (s *BaseMySqlParserListener) ExitPrimaryKeyColumnConstraint(ctx *PrimaryKeyColumnConstraintContext) { +} + +// EnterUniqueKeyColumnConstraint is called when production uniqueKeyColumnConstraint is entered. +func (s *BaseMySqlParserListener) EnterUniqueKeyColumnConstraint(ctx *UniqueKeyColumnConstraintContext) { +} + +// ExitUniqueKeyColumnConstraint is called when production uniqueKeyColumnConstraint is exited. +func (s *BaseMySqlParserListener) ExitUniqueKeyColumnConstraint(ctx *UniqueKeyColumnConstraintContext) { +} + +// EnterCommentColumnConstraint is called when production commentColumnConstraint is entered. +func (s *BaseMySqlParserListener) EnterCommentColumnConstraint(ctx *CommentColumnConstraintContext) {} + +// ExitCommentColumnConstraint is called when production commentColumnConstraint is exited. +func (s *BaseMySqlParserListener) ExitCommentColumnConstraint(ctx *CommentColumnConstraintContext) {} + +// EnterFormatColumnConstraint is called when production formatColumnConstraint is entered. +func (s *BaseMySqlParserListener) EnterFormatColumnConstraint(ctx *FormatColumnConstraintContext) {} + +// ExitFormatColumnConstraint is called when production formatColumnConstraint is exited. +func (s *BaseMySqlParserListener) ExitFormatColumnConstraint(ctx *FormatColumnConstraintContext) {} + +// EnterStorageColumnConstraint is called when production storageColumnConstraint is entered. +func (s *BaseMySqlParserListener) EnterStorageColumnConstraint(ctx *StorageColumnConstraintContext) {} + +// ExitStorageColumnConstraint is called when production storageColumnConstraint is exited. +func (s *BaseMySqlParserListener) ExitStorageColumnConstraint(ctx *StorageColumnConstraintContext) {} + +// EnterReferenceColumnConstraint is called when production referenceColumnConstraint is entered. +func (s *BaseMySqlParserListener) EnterReferenceColumnConstraint(ctx *ReferenceColumnConstraintContext) { +} + +// ExitReferenceColumnConstraint is called when production referenceColumnConstraint is exited. +func (s *BaseMySqlParserListener) ExitReferenceColumnConstraint(ctx *ReferenceColumnConstraintContext) { +} + +// EnterCollateColumnConstraint is called when production collateColumnConstraint is entered. +func (s *BaseMySqlParserListener) EnterCollateColumnConstraint(ctx *CollateColumnConstraintContext) {} + +// ExitCollateColumnConstraint is called when production collateColumnConstraint is exited. +func (s *BaseMySqlParserListener) ExitCollateColumnConstraint(ctx *CollateColumnConstraintContext) {} + +// EnterGeneratedColumnConstraint is called when production generatedColumnConstraint is entered. +func (s *BaseMySqlParserListener) EnterGeneratedColumnConstraint(ctx *GeneratedColumnConstraintContext) { +} + +// ExitGeneratedColumnConstraint is called when production generatedColumnConstraint is exited. +func (s *BaseMySqlParserListener) ExitGeneratedColumnConstraint(ctx *GeneratedColumnConstraintContext) { +} + +// EnterSerialDefaultColumnConstraint is called when production serialDefaultColumnConstraint is entered. +func (s *BaseMySqlParserListener) EnterSerialDefaultColumnConstraint(ctx *SerialDefaultColumnConstraintContext) { +} + +// ExitSerialDefaultColumnConstraint is called when production serialDefaultColumnConstraint is exited. +func (s *BaseMySqlParserListener) ExitSerialDefaultColumnConstraint(ctx *SerialDefaultColumnConstraintContext) { +} + +// EnterCheckColumnConstraint is called when production checkColumnConstraint is entered. +func (s *BaseMySqlParserListener) EnterCheckColumnConstraint(ctx *CheckColumnConstraintContext) {} + +// ExitCheckColumnConstraint is called when production checkColumnConstraint is exited. +func (s *BaseMySqlParserListener) ExitCheckColumnConstraint(ctx *CheckColumnConstraintContext) {} + +// EnterPrimaryKeyTableConstraint is called when production primaryKeyTableConstraint is entered. +func (s *BaseMySqlParserListener) EnterPrimaryKeyTableConstraint(ctx *PrimaryKeyTableConstraintContext) { +} + +// ExitPrimaryKeyTableConstraint is called when production primaryKeyTableConstraint is exited. +func (s *BaseMySqlParserListener) ExitPrimaryKeyTableConstraint(ctx *PrimaryKeyTableConstraintContext) { +} + +// EnterUniqueKeyTableConstraint is called when production uniqueKeyTableConstraint is entered. +func (s *BaseMySqlParserListener) EnterUniqueKeyTableConstraint(ctx *UniqueKeyTableConstraintContext) { +} + +// ExitUniqueKeyTableConstraint is called when production uniqueKeyTableConstraint is exited. +func (s *BaseMySqlParserListener) ExitUniqueKeyTableConstraint(ctx *UniqueKeyTableConstraintContext) { +} + +// EnterForeignKeyTableConstraint is called when production foreignKeyTableConstraint is entered. +func (s *BaseMySqlParserListener) EnterForeignKeyTableConstraint(ctx *ForeignKeyTableConstraintContext) { +} + +// ExitForeignKeyTableConstraint is called when production foreignKeyTableConstraint is exited. +func (s *BaseMySqlParserListener) ExitForeignKeyTableConstraint(ctx *ForeignKeyTableConstraintContext) { +} + +// EnterCheckTableConstraint is called when production checkTableConstraint is entered. +func (s *BaseMySqlParserListener) EnterCheckTableConstraint(ctx *CheckTableConstraintContext) {} + +// ExitCheckTableConstraint is called when production checkTableConstraint is exited. +func (s *BaseMySqlParserListener) ExitCheckTableConstraint(ctx *CheckTableConstraintContext) {} + +// EnterReferenceDefinition is called when production referenceDefinition is entered. +func (s *BaseMySqlParserListener) EnterReferenceDefinition(ctx *ReferenceDefinitionContext) {} + +// ExitReferenceDefinition is called when production referenceDefinition is exited. +func (s *BaseMySqlParserListener) ExitReferenceDefinition(ctx *ReferenceDefinitionContext) {} + +// EnterReferenceAction is called when production referenceAction is entered. +func (s *BaseMySqlParserListener) EnterReferenceAction(ctx *ReferenceActionContext) {} + +// ExitReferenceAction is called when production referenceAction is exited. +func (s *BaseMySqlParserListener) ExitReferenceAction(ctx *ReferenceActionContext) {} + +// EnterReferenceControlType is called when production referenceControlType is entered. +func (s *BaseMySqlParserListener) EnterReferenceControlType(ctx *ReferenceControlTypeContext) {} + +// ExitReferenceControlType is called when production referenceControlType is exited. +func (s *BaseMySqlParserListener) ExitReferenceControlType(ctx *ReferenceControlTypeContext) {} + +// EnterSimpleIndexDeclaration is called when production simpleIndexDeclaration is entered. +func (s *BaseMySqlParserListener) EnterSimpleIndexDeclaration(ctx *SimpleIndexDeclarationContext) {} + +// ExitSimpleIndexDeclaration is called when production simpleIndexDeclaration is exited. +func (s *BaseMySqlParserListener) ExitSimpleIndexDeclaration(ctx *SimpleIndexDeclarationContext) {} + +// EnterSpecialIndexDeclaration is called when production specialIndexDeclaration is entered. +func (s *BaseMySqlParserListener) EnterSpecialIndexDeclaration(ctx *SpecialIndexDeclarationContext) {} + +// ExitSpecialIndexDeclaration is called when production specialIndexDeclaration is exited. +func (s *BaseMySqlParserListener) ExitSpecialIndexDeclaration(ctx *SpecialIndexDeclarationContext) {} + +// EnterTableOptionEngine is called when production tableOptionEngine is entered. +func (s *BaseMySqlParserListener) EnterTableOptionEngine(ctx *TableOptionEngineContext) {} + +// ExitTableOptionEngine is called when production tableOptionEngine is exited. +func (s *BaseMySqlParserListener) ExitTableOptionEngine(ctx *TableOptionEngineContext) {} + +// EnterTableOptionEngineAttribute is called when production tableOptionEngineAttribute is entered. +func (s *BaseMySqlParserListener) EnterTableOptionEngineAttribute(ctx *TableOptionEngineAttributeContext) { +} + +// ExitTableOptionEngineAttribute is called when production tableOptionEngineAttribute is exited. +func (s *BaseMySqlParserListener) ExitTableOptionEngineAttribute(ctx *TableOptionEngineAttributeContext) { +} + +// EnterTableOptionAutoextendSize is called when production tableOptionAutoextendSize is entered. +func (s *BaseMySqlParserListener) EnterTableOptionAutoextendSize(ctx *TableOptionAutoextendSizeContext) { +} + +// ExitTableOptionAutoextendSize is called when production tableOptionAutoextendSize is exited. +func (s *BaseMySqlParserListener) ExitTableOptionAutoextendSize(ctx *TableOptionAutoextendSizeContext) { +} + +// EnterTableOptionAutoIncrement is called when production tableOptionAutoIncrement is entered. +func (s *BaseMySqlParserListener) EnterTableOptionAutoIncrement(ctx *TableOptionAutoIncrementContext) { +} + +// ExitTableOptionAutoIncrement is called when production tableOptionAutoIncrement is exited. +func (s *BaseMySqlParserListener) ExitTableOptionAutoIncrement(ctx *TableOptionAutoIncrementContext) { +} + +// EnterTableOptionAverage is called when production tableOptionAverage is entered. +func (s *BaseMySqlParserListener) EnterTableOptionAverage(ctx *TableOptionAverageContext) {} + +// ExitTableOptionAverage is called when production tableOptionAverage is exited. +func (s *BaseMySqlParserListener) ExitTableOptionAverage(ctx *TableOptionAverageContext) {} + +// EnterTableOptionCharset is called when production tableOptionCharset is entered. +func (s *BaseMySqlParserListener) EnterTableOptionCharset(ctx *TableOptionCharsetContext) {} + +// ExitTableOptionCharset is called when production tableOptionCharset is exited. +func (s *BaseMySqlParserListener) ExitTableOptionCharset(ctx *TableOptionCharsetContext) {} + +// EnterTableOptionChecksum is called when production tableOptionChecksum is entered. +func (s *BaseMySqlParserListener) EnterTableOptionChecksum(ctx *TableOptionChecksumContext) {} + +// ExitTableOptionChecksum is called when production tableOptionChecksum is exited. +func (s *BaseMySqlParserListener) ExitTableOptionChecksum(ctx *TableOptionChecksumContext) {} + +// EnterTableOptionCollate is called when production tableOptionCollate is entered. +func (s *BaseMySqlParserListener) EnterTableOptionCollate(ctx *TableOptionCollateContext) {} + +// ExitTableOptionCollate is called when production tableOptionCollate is exited. +func (s *BaseMySqlParserListener) ExitTableOptionCollate(ctx *TableOptionCollateContext) {} + +// EnterTableOptionComment is called when production tableOptionComment is entered. +func (s *BaseMySqlParserListener) EnterTableOptionComment(ctx *TableOptionCommentContext) {} + +// ExitTableOptionComment is called when production tableOptionComment is exited. +func (s *BaseMySqlParserListener) ExitTableOptionComment(ctx *TableOptionCommentContext) {} + +// EnterTableOptionCompression is called when production tableOptionCompression is entered. +func (s *BaseMySqlParserListener) EnterTableOptionCompression(ctx *TableOptionCompressionContext) {} + +// ExitTableOptionCompression is called when production tableOptionCompression is exited. +func (s *BaseMySqlParserListener) ExitTableOptionCompression(ctx *TableOptionCompressionContext) {} + +// EnterTableOptionConnection is called when production tableOptionConnection is entered. +func (s *BaseMySqlParserListener) EnterTableOptionConnection(ctx *TableOptionConnectionContext) {} + +// ExitTableOptionConnection is called when production tableOptionConnection is exited. +func (s *BaseMySqlParserListener) ExitTableOptionConnection(ctx *TableOptionConnectionContext) {} + +// EnterTableOptionDataDirectory is called when production tableOptionDataDirectory is entered. +func (s *BaseMySqlParserListener) EnterTableOptionDataDirectory(ctx *TableOptionDataDirectoryContext) { +} + +// ExitTableOptionDataDirectory is called when production tableOptionDataDirectory is exited. +func (s *BaseMySqlParserListener) ExitTableOptionDataDirectory(ctx *TableOptionDataDirectoryContext) { +} + +// EnterTableOptionDelay is called when production tableOptionDelay is entered. +func (s *BaseMySqlParserListener) EnterTableOptionDelay(ctx *TableOptionDelayContext) {} + +// ExitTableOptionDelay is called when production tableOptionDelay is exited. +func (s *BaseMySqlParserListener) ExitTableOptionDelay(ctx *TableOptionDelayContext) {} + +// EnterTableOptionEncryption is called when production tableOptionEncryption is entered. +func (s *BaseMySqlParserListener) EnterTableOptionEncryption(ctx *TableOptionEncryptionContext) {} + +// ExitTableOptionEncryption is called when production tableOptionEncryption is exited. +func (s *BaseMySqlParserListener) ExitTableOptionEncryption(ctx *TableOptionEncryptionContext) {} + +// EnterTableOptionPageCompressed is called when production tableOptionPageCompressed is entered. +func (s *BaseMySqlParserListener) EnterTableOptionPageCompressed(ctx *TableOptionPageCompressedContext) { +} + +// ExitTableOptionPageCompressed is called when production tableOptionPageCompressed is exited. +func (s *BaseMySqlParserListener) ExitTableOptionPageCompressed(ctx *TableOptionPageCompressedContext) { +} + +// EnterTableOptionPageCompressionLevel is called when production tableOptionPageCompressionLevel is entered. +func (s *BaseMySqlParserListener) EnterTableOptionPageCompressionLevel(ctx *TableOptionPageCompressionLevelContext) { +} + +// ExitTableOptionPageCompressionLevel is called when production tableOptionPageCompressionLevel is exited. +func (s *BaseMySqlParserListener) ExitTableOptionPageCompressionLevel(ctx *TableOptionPageCompressionLevelContext) { +} + +// EnterTableOptionEncryptionKeyId is called when production tableOptionEncryptionKeyId is entered. +func (s *BaseMySqlParserListener) EnterTableOptionEncryptionKeyId(ctx *TableOptionEncryptionKeyIdContext) { +} + +// ExitTableOptionEncryptionKeyId is called when production tableOptionEncryptionKeyId is exited. +func (s *BaseMySqlParserListener) ExitTableOptionEncryptionKeyId(ctx *TableOptionEncryptionKeyIdContext) { +} + +// EnterTableOptionIndexDirectory is called when production tableOptionIndexDirectory is entered. +func (s *BaseMySqlParserListener) EnterTableOptionIndexDirectory(ctx *TableOptionIndexDirectoryContext) { +} + +// ExitTableOptionIndexDirectory is called when production tableOptionIndexDirectory is exited. +func (s *BaseMySqlParserListener) ExitTableOptionIndexDirectory(ctx *TableOptionIndexDirectoryContext) { +} + +// EnterTableOptionInsertMethod is called when production tableOptionInsertMethod is entered. +func (s *BaseMySqlParserListener) EnterTableOptionInsertMethod(ctx *TableOptionInsertMethodContext) {} + +// ExitTableOptionInsertMethod is called when production tableOptionInsertMethod is exited. +func (s *BaseMySqlParserListener) ExitTableOptionInsertMethod(ctx *TableOptionInsertMethodContext) {} + +// EnterTableOptionKeyBlockSize is called when production tableOptionKeyBlockSize is entered. +func (s *BaseMySqlParserListener) EnterTableOptionKeyBlockSize(ctx *TableOptionKeyBlockSizeContext) {} + +// ExitTableOptionKeyBlockSize is called when production tableOptionKeyBlockSize is exited. +func (s *BaseMySqlParserListener) ExitTableOptionKeyBlockSize(ctx *TableOptionKeyBlockSizeContext) {} + +// EnterTableOptionMaxRows is called when production tableOptionMaxRows is entered. +func (s *BaseMySqlParserListener) EnterTableOptionMaxRows(ctx *TableOptionMaxRowsContext) {} + +// ExitTableOptionMaxRows is called when production tableOptionMaxRows is exited. +func (s *BaseMySqlParserListener) ExitTableOptionMaxRows(ctx *TableOptionMaxRowsContext) {} + +// EnterTableOptionMinRows is called when production tableOptionMinRows is entered. +func (s *BaseMySqlParserListener) EnterTableOptionMinRows(ctx *TableOptionMinRowsContext) {} + +// ExitTableOptionMinRows is called when production tableOptionMinRows is exited. +func (s *BaseMySqlParserListener) ExitTableOptionMinRows(ctx *TableOptionMinRowsContext) {} + +// EnterTableOptionPackKeys is called when production tableOptionPackKeys is entered. +func (s *BaseMySqlParserListener) EnterTableOptionPackKeys(ctx *TableOptionPackKeysContext) {} + +// ExitTableOptionPackKeys is called when production tableOptionPackKeys is exited. +func (s *BaseMySqlParserListener) ExitTableOptionPackKeys(ctx *TableOptionPackKeysContext) {} + +// EnterTableOptionPassword is called when production tableOptionPassword is entered. +func (s *BaseMySqlParserListener) EnterTableOptionPassword(ctx *TableOptionPasswordContext) {} + +// ExitTableOptionPassword is called when production tableOptionPassword is exited. +func (s *BaseMySqlParserListener) ExitTableOptionPassword(ctx *TableOptionPasswordContext) {} + +// EnterTableOptionRowFormat is called when production tableOptionRowFormat is entered. +func (s *BaseMySqlParserListener) EnterTableOptionRowFormat(ctx *TableOptionRowFormatContext) {} + +// ExitTableOptionRowFormat is called when production tableOptionRowFormat is exited. +func (s *BaseMySqlParserListener) ExitTableOptionRowFormat(ctx *TableOptionRowFormatContext) {} + +// EnterTableOptionStartTransaction is called when production tableOptionStartTransaction is entered. +func (s *BaseMySqlParserListener) EnterTableOptionStartTransaction(ctx *TableOptionStartTransactionContext) { +} + +// ExitTableOptionStartTransaction is called when production tableOptionStartTransaction is exited. +func (s *BaseMySqlParserListener) ExitTableOptionStartTransaction(ctx *TableOptionStartTransactionContext) { +} + +// EnterTableOptionSecondaryEngineAttribute is called when production tableOptionSecondaryEngineAttribute is entered. +func (s *BaseMySqlParserListener) EnterTableOptionSecondaryEngineAttribute(ctx *TableOptionSecondaryEngineAttributeContext) { +} + +// ExitTableOptionSecondaryEngineAttribute is called when production tableOptionSecondaryEngineAttribute is exited. +func (s *BaseMySqlParserListener) ExitTableOptionSecondaryEngineAttribute(ctx *TableOptionSecondaryEngineAttributeContext) { +} + +// EnterTableOptionRecalculation is called when production tableOptionRecalculation is entered. +func (s *BaseMySqlParserListener) EnterTableOptionRecalculation(ctx *TableOptionRecalculationContext) { +} + +// ExitTableOptionRecalculation is called when production tableOptionRecalculation is exited. +func (s *BaseMySqlParserListener) ExitTableOptionRecalculation(ctx *TableOptionRecalculationContext) { +} + +// EnterTableOptionPersistent is called when production tableOptionPersistent is entered. +func (s *BaseMySqlParserListener) EnterTableOptionPersistent(ctx *TableOptionPersistentContext) {} + +// ExitTableOptionPersistent is called when production tableOptionPersistent is exited. +func (s *BaseMySqlParserListener) ExitTableOptionPersistent(ctx *TableOptionPersistentContext) {} + +// EnterTableOptionSamplePage is called when production tableOptionSamplePage is entered. +func (s *BaseMySqlParserListener) EnterTableOptionSamplePage(ctx *TableOptionSamplePageContext) {} + +// ExitTableOptionSamplePage is called when production tableOptionSamplePage is exited. +func (s *BaseMySqlParserListener) ExitTableOptionSamplePage(ctx *TableOptionSamplePageContext) {} + +// EnterTableOptionTablespace is called when production tableOptionTablespace is entered. +func (s *BaseMySqlParserListener) EnterTableOptionTablespace(ctx *TableOptionTablespaceContext) {} + +// ExitTableOptionTablespace is called when production tableOptionTablespace is exited. +func (s *BaseMySqlParserListener) ExitTableOptionTablespace(ctx *TableOptionTablespaceContext) {} + +// EnterTableOptionTableType is called when production tableOptionTableType is entered. +func (s *BaseMySqlParserListener) EnterTableOptionTableType(ctx *TableOptionTableTypeContext) {} + +// ExitTableOptionTableType is called when production tableOptionTableType is exited. +func (s *BaseMySqlParserListener) ExitTableOptionTableType(ctx *TableOptionTableTypeContext) {} + +// EnterTableOptionTransactional is called when production tableOptionTransactional is entered. +func (s *BaseMySqlParserListener) EnterTableOptionTransactional(ctx *TableOptionTransactionalContext) { +} + +// ExitTableOptionTransactional is called when production tableOptionTransactional is exited. +func (s *BaseMySqlParserListener) ExitTableOptionTransactional(ctx *TableOptionTransactionalContext) { +} + +// EnterTableOptionUnion is called when production tableOptionUnion is entered. +func (s *BaseMySqlParserListener) EnterTableOptionUnion(ctx *TableOptionUnionContext) {} + +// ExitTableOptionUnion is called when production tableOptionUnion is exited. +func (s *BaseMySqlParserListener) ExitTableOptionUnion(ctx *TableOptionUnionContext) {} + +// EnterTableType is called when production tableType is entered. +func (s *BaseMySqlParserListener) EnterTableType(ctx *TableTypeContext) {} + +// ExitTableType is called when production tableType is exited. +func (s *BaseMySqlParserListener) ExitTableType(ctx *TableTypeContext) {} + +// EnterTablespaceStorage is called when production tablespaceStorage is entered. +func (s *BaseMySqlParserListener) EnterTablespaceStorage(ctx *TablespaceStorageContext) {} + +// ExitTablespaceStorage is called when production tablespaceStorage is exited. +func (s *BaseMySqlParserListener) ExitTablespaceStorage(ctx *TablespaceStorageContext) {} + +// EnterPartitionDefinitions is called when production partitionDefinitions is entered. +func (s *BaseMySqlParserListener) EnterPartitionDefinitions(ctx *PartitionDefinitionsContext) {} + +// ExitPartitionDefinitions is called when production partitionDefinitions is exited. +func (s *BaseMySqlParserListener) ExitPartitionDefinitions(ctx *PartitionDefinitionsContext) {} + +// EnterPartitionFunctionHash is called when production partitionFunctionHash is entered. +func (s *BaseMySqlParserListener) EnterPartitionFunctionHash(ctx *PartitionFunctionHashContext) {} + +// ExitPartitionFunctionHash is called when production partitionFunctionHash is exited. +func (s *BaseMySqlParserListener) ExitPartitionFunctionHash(ctx *PartitionFunctionHashContext) {} + +// EnterPartitionFunctionKey is called when production partitionFunctionKey is entered. +func (s *BaseMySqlParserListener) EnterPartitionFunctionKey(ctx *PartitionFunctionKeyContext) {} + +// ExitPartitionFunctionKey is called when production partitionFunctionKey is exited. +func (s *BaseMySqlParserListener) ExitPartitionFunctionKey(ctx *PartitionFunctionKeyContext) {} + +// EnterPartitionFunctionRange is called when production partitionFunctionRange is entered. +func (s *BaseMySqlParserListener) EnterPartitionFunctionRange(ctx *PartitionFunctionRangeContext) {} + +// ExitPartitionFunctionRange is called when production partitionFunctionRange is exited. +func (s *BaseMySqlParserListener) ExitPartitionFunctionRange(ctx *PartitionFunctionRangeContext) {} + +// EnterPartitionFunctionList is called when production partitionFunctionList is entered. +func (s *BaseMySqlParserListener) EnterPartitionFunctionList(ctx *PartitionFunctionListContext) {} + +// ExitPartitionFunctionList is called when production partitionFunctionList is exited. +func (s *BaseMySqlParserListener) ExitPartitionFunctionList(ctx *PartitionFunctionListContext) {} + +// EnterSubPartitionFunctionHash is called when production subPartitionFunctionHash is entered. +func (s *BaseMySqlParserListener) EnterSubPartitionFunctionHash(ctx *SubPartitionFunctionHashContext) { +} + +// ExitSubPartitionFunctionHash is called when production subPartitionFunctionHash is exited. +func (s *BaseMySqlParserListener) ExitSubPartitionFunctionHash(ctx *SubPartitionFunctionHashContext) { +} + +// EnterSubPartitionFunctionKey is called when production subPartitionFunctionKey is entered. +func (s *BaseMySqlParserListener) EnterSubPartitionFunctionKey(ctx *SubPartitionFunctionKeyContext) {} + +// ExitSubPartitionFunctionKey is called when production subPartitionFunctionKey is exited. +func (s *BaseMySqlParserListener) ExitSubPartitionFunctionKey(ctx *SubPartitionFunctionKeyContext) {} + +// EnterPartitionComparison is called when production partitionComparison is entered. +func (s *BaseMySqlParserListener) EnterPartitionComparison(ctx *PartitionComparisonContext) {} + +// ExitPartitionComparison is called when production partitionComparison is exited. +func (s *BaseMySqlParserListener) ExitPartitionComparison(ctx *PartitionComparisonContext) {} + +// EnterPartitionListAtom is called when production partitionListAtom is entered. +func (s *BaseMySqlParserListener) EnterPartitionListAtom(ctx *PartitionListAtomContext) {} + +// ExitPartitionListAtom is called when production partitionListAtom is exited. +func (s *BaseMySqlParserListener) ExitPartitionListAtom(ctx *PartitionListAtomContext) {} + +// EnterPartitionListVector is called when production partitionListVector is entered. +func (s *BaseMySqlParserListener) EnterPartitionListVector(ctx *PartitionListVectorContext) {} + +// ExitPartitionListVector is called when production partitionListVector is exited. +func (s *BaseMySqlParserListener) ExitPartitionListVector(ctx *PartitionListVectorContext) {} + +// EnterPartitionSimple is called when production partitionSimple is entered. +func (s *BaseMySqlParserListener) EnterPartitionSimple(ctx *PartitionSimpleContext) {} + +// ExitPartitionSimple is called when production partitionSimple is exited. +func (s *BaseMySqlParserListener) ExitPartitionSimple(ctx *PartitionSimpleContext) {} + +// EnterPartitionDefinerAtom is called when production partitionDefinerAtom is entered. +func (s *BaseMySqlParserListener) EnterPartitionDefinerAtom(ctx *PartitionDefinerAtomContext) {} + +// ExitPartitionDefinerAtom is called when production partitionDefinerAtom is exited. +func (s *BaseMySqlParserListener) ExitPartitionDefinerAtom(ctx *PartitionDefinerAtomContext) {} + +// EnterPartitionDefinerVector is called when production partitionDefinerVector is entered. +func (s *BaseMySqlParserListener) EnterPartitionDefinerVector(ctx *PartitionDefinerVectorContext) {} + +// ExitPartitionDefinerVector is called when production partitionDefinerVector is exited. +func (s *BaseMySqlParserListener) ExitPartitionDefinerVector(ctx *PartitionDefinerVectorContext) {} + +// EnterSubpartitionDefinition is called when production subpartitionDefinition is entered. +func (s *BaseMySqlParserListener) EnterSubpartitionDefinition(ctx *SubpartitionDefinitionContext) {} + +// ExitSubpartitionDefinition is called when production subpartitionDefinition is exited. +func (s *BaseMySqlParserListener) ExitSubpartitionDefinition(ctx *SubpartitionDefinitionContext) {} + +// EnterPartitionOptionEngine is called when production partitionOptionEngine is entered. +func (s *BaseMySqlParserListener) EnterPartitionOptionEngine(ctx *PartitionOptionEngineContext) {} + +// ExitPartitionOptionEngine is called when production partitionOptionEngine is exited. +func (s *BaseMySqlParserListener) ExitPartitionOptionEngine(ctx *PartitionOptionEngineContext) {} + +// EnterPartitionOptionComment is called when production partitionOptionComment is entered. +func (s *BaseMySqlParserListener) EnterPartitionOptionComment(ctx *PartitionOptionCommentContext) {} + +// ExitPartitionOptionComment is called when production partitionOptionComment is exited. +func (s *BaseMySqlParserListener) ExitPartitionOptionComment(ctx *PartitionOptionCommentContext) {} + +// EnterPartitionOptionDataDirectory is called when production partitionOptionDataDirectory is entered. +func (s *BaseMySqlParserListener) EnterPartitionOptionDataDirectory(ctx *PartitionOptionDataDirectoryContext) { +} + +// ExitPartitionOptionDataDirectory is called when production partitionOptionDataDirectory is exited. +func (s *BaseMySqlParserListener) ExitPartitionOptionDataDirectory(ctx *PartitionOptionDataDirectoryContext) { +} + +// EnterPartitionOptionIndexDirectory is called when production partitionOptionIndexDirectory is entered. +func (s *BaseMySqlParserListener) EnterPartitionOptionIndexDirectory(ctx *PartitionOptionIndexDirectoryContext) { +} + +// ExitPartitionOptionIndexDirectory is called when production partitionOptionIndexDirectory is exited. +func (s *BaseMySqlParserListener) ExitPartitionOptionIndexDirectory(ctx *PartitionOptionIndexDirectoryContext) { +} + +// EnterPartitionOptionMaxRows is called when production partitionOptionMaxRows is entered. +func (s *BaseMySqlParserListener) EnterPartitionOptionMaxRows(ctx *PartitionOptionMaxRowsContext) {} + +// ExitPartitionOptionMaxRows is called when production partitionOptionMaxRows is exited. +func (s *BaseMySqlParserListener) ExitPartitionOptionMaxRows(ctx *PartitionOptionMaxRowsContext) {} + +// EnterPartitionOptionMinRows is called when production partitionOptionMinRows is entered. +func (s *BaseMySqlParserListener) EnterPartitionOptionMinRows(ctx *PartitionOptionMinRowsContext) {} + +// ExitPartitionOptionMinRows is called when production partitionOptionMinRows is exited. +func (s *BaseMySqlParserListener) ExitPartitionOptionMinRows(ctx *PartitionOptionMinRowsContext) {} + +// EnterPartitionOptionTablespace is called when production partitionOptionTablespace is entered. +func (s *BaseMySqlParserListener) EnterPartitionOptionTablespace(ctx *PartitionOptionTablespaceContext) { +} + +// ExitPartitionOptionTablespace is called when production partitionOptionTablespace is exited. +func (s *BaseMySqlParserListener) ExitPartitionOptionTablespace(ctx *PartitionOptionTablespaceContext) { +} + +// EnterPartitionOptionNodeGroup is called when production partitionOptionNodeGroup is entered. +func (s *BaseMySqlParserListener) EnterPartitionOptionNodeGroup(ctx *PartitionOptionNodeGroupContext) { +} + +// ExitPartitionOptionNodeGroup is called when production partitionOptionNodeGroup is exited. +func (s *BaseMySqlParserListener) ExitPartitionOptionNodeGroup(ctx *PartitionOptionNodeGroupContext) { +} + +// EnterAlterSimpleDatabase is called when production alterSimpleDatabase is entered. +func (s *BaseMySqlParserListener) EnterAlterSimpleDatabase(ctx *AlterSimpleDatabaseContext) {} + +// ExitAlterSimpleDatabase is called when production alterSimpleDatabase is exited. +func (s *BaseMySqlParserListener) ExitAlterSimpleDatabase(ctx *AlterSimpleDatabaseContext) {} + +// EnterAlterUpgradeName is called when production alterUpgradeName is entered. +func (s *BaseMySqlParserListener) EnterAlterUpgradeName(ctx *AlterUpgradeNameContext) {} + +// ExitAlterUpgradeName is called when production alterUpgradeName is exited. +func (s *BaseMySqlParserListener) ExitAlterUpgradeName(ctx *AlterUpgradeNameContext) {} + +// EnterAlterEvent is called when production alterEvent is entered. +func (s *BaseMySqlParserListener) EnterAlterEvent(ctx *AlterEventContext) {} + +// ExitAlterEvent is called when production alterEvent is exited. +func (s *BaseMySqlParserListener) ExitAlterEvent(ctx *AlterEventContext) {} + +// EnterAlterFunction is called when production alterFunction is entered. +func (s *BaseMySqlParserListener) EnterAlterFunction(ctx *AlterFunctionContext) {} + +// ExitAlterFunction is called when production alterFunction is exited. +func (s *BaseMySqlParserListener) ExitAlterFunction(ctx *AlterFunctionContext) {} + +// EnterAlterInstance is called when production alterInstance is entered. +func (s *BaseMySqlParserListener) EnterAlterInstance(ctx *AlterInstanceContext) {} + +// ExitAlterInstance is called when production alterInstance is exited. +func (s *BaseMySqlParserListener) ExitAlterInstance(ctx *AlterInstanceContext) {} + +// EnterAlterLogfileGroup is called when production alterLogfileGroup is entered. +func (s *BaseMySqlParserListener) EnterAlterLogfileGroup(ctx *AlterLogfileGroupContext) {} + +// ExitAlterLogfileGroup is called when production alterLogfileGroup is exited. +func (s *BaseMySqlParserListener) ExitAlterLogfileGroup(ctx *AlterLogfileGroupContext) {} + +// EnterAlterProcedure is called when production alterProcedure is entered. +func (s *BaseMySqlParserListener) EnterAlterProcedure(ctx *AlterProcedureContext) {} + +// ExitAlterProcedure is called when production alterProcedure is exited. +func (s *BaseMySqlParserListener) ExitAlterProcedure(ctx *AlterProcedureContext) {} + +// EnterAlterServer is called when production alterServer is entered. +func (s *BaseMySqlParserListener) EnterAlterServer(ctx *AlterServerContext) {} + +// ExitAlterServer is called when production alterServer is exited. +func (s *BaseMySqlParserListener) ExitAlterServer(ctx *AlterServerContext) {} + +// EnterAlterTable is called when production alterTable is entered. +func (s *BaseMySqlParserListener) EnterAlterTable(ctx *AlterTableContext) {} + +// ExitAlterTable is called when production alterTable is exited. +func (s *BaseMySqlParserListener) ExitAlterTable(ctx *AlterTableContext) {} + +// EnterAlterTablespace is called when production alterTablespace is entered. +func (s *BaseMySqlParserListener) EnterAlterTablespace(ctx *AlterTablespaceContext) {} + +// ExitAlterTablespace is called when production alterTablespace is exited. +func (s *BaseMySqlParserListener) ExitAlterTablespace(ctx *AlterTablespaceContext) {} + +// EnterAlterView is called when production alterView is entered. +func (s *BaseMySqlParserListener) EnterAlterView(ctx *AlterViewContext) {} + +// ExitAlterView is called when production alterView is exited. +func (s *BaseMySqlParserListener) ExitAlterView(ctx *AlterViewContext) {} + +// EnterAlterByTableOption is called when production alterByTableOption is entered. +func (s *BaseMySqlParserListener) EnterAlterByTableOption(ctx *AlterByTableOptionContext) {} + +// ExitAlterByTableOption is called when production alterByTableOption is exited. +func (s *BaseMySqlParserListener) ExitAlterByTableOption(ctx *AlterByTableOptionContext) {} + +// EnterAlterByAddColumn is called when production alterByAddColumn is entered. +func (s *BaseMySqlParserListener) EnterAlterByAddColumn(ctx *AlterByAddColumnContext) {} + +// ExitAlterByAddColumn is called when production alterByAddColumn is exited. +func (s *BaseMySqlParserListener) ExitAlterByAddColumn(ctx *AlterByAddColumnContext) {} + +// EnterAlterByAddColumns is called when production alterByAddColumns is entered. +func (s *BaseMySqlParserListener) EnterAlterByAddColumns(ctx *AlterByAddColumnsContext) {} + +// ExitAlterByAddColumns is called when production alterByAddColumns is exited. +func (s *BaseMySqlParserListener) ExitAlterByAddColumns(ctx *AlterByAddColumnsContext) {} + +// EnterAlterByAddIndex is called when production alterByAddIndex is entered. +func (s *BaseMySqlParserListener) EnterAlterByAddIndex(ctx *AlterByAddIndexContext) {} + +// ExitAlterByAddIndex is called when production alterByAddIndex is exited. +func (s *BaseMySqlParserListener) ExitAlterByAddIndex(ctx *AlterByAddIndexContext) {} + +// EnterAlterByAddPrimaryKey is called when production alterByAddPrimaryKey is entered. +func (s *BaseMySqlParserListener) EnterAlterByAddPrimaryKey(ctx *AlterByAddPrimaryKeyContext) {} + +// ExitAlterByAddPrimaryKey is called when production alterByAddPrimaryKey is exited. +func (s *BaseMySqlParserListener) ExitAlterByAddPrimaryKey(ctx *AlterByAddPrimaryKeyContext) {} + +// EnterAlterByAddUniqueKey is called when production alterByAddUniqueKey is entered. +func (s *BaseMySqlParserListener) EnterAlterByAddUniqueKey(ctx *AlterByAddUniqueKeyContext) {} + +// ExitAlterByAddUniqueKey is called when production alterByAddUniqueKey is exited. +func (s *BaseMySqlParserListener) ExitAlterByAddUniqueKey(ctx *AlterByAddUniqueKeyContext) {} + +// EnterAlterByAddSpecialIndex is called when production alterByAddSpecialIndex is entered. +func (s *BaseMySqlParserListener) EnterAlterByAddSpecialIndex(ctx *AlterByAddSpecialIndexContext) {} + +// ExitAlterByAddSpecialIndex is called when production alterByAddSpecialIndex is exited. +func (s *BaseMySqlParserListener) ExitAlterByAddSpecialIndex(ctx *AlterByAddSpecialIndexContext) {} + +// EnterAlterByAddForeignKey is called when production alterByAddForeignKey is entered. +func (s *BaseMySqlParserListener) EnterAlterByAddForeignKey(ctx *AlterByAddForeignKeyContext) {} + +// ExitAlterByAddForeignKey is called when production alterByAddForeignKey is exited. +func (s *BaseMySqlParserListener) ExitAlterByAddForeignKey(ctx *AlterByAddForeignKeyContext) {} + +// EnterAlterByAddCheckTableConstraint is called when production alterByAddCheckTableConstraint is entered. +func (s *BaseMySqlParserListener) EnterAlterByAddCheckTableConstraint(ctx *AlterByAddCheckTableConstraintContext) { +} + +// ExitAlterByAddCheckTableConstraint is called when production alterByAddCheckTableConstraint is exited. +func (s *BaseMySqlParserListener) ExitAlterByAddCheckTableConstraint(ctx *AlterByAddCheckTableConstraintContext) { +} + +// EnterAlterByAlterCheckTableConstraint is called when production alterByAlterCheckTableConstraint is entered. +func (s *BaseMySqlParserListener) EnterAlterByAlterCheckTableConstraint(ctx *AlterByAlterCheckTableConstraintContext) { +} + +// ExitAlterByAlterCheckTableConstraint is called when production alterByAlterCheckTableConstraint is exited. +func (s *BaseMySqlParserListener) ExitAlterByAlterCheckTableConstraint(ctx *AlterByAlterCheckTableConstraintContext) { +} + +// EnterAlterBySetAlgorithm is called when production alterBySetAlgorithm is entered. +func (s *BaseMySqlParserListener) EnterAlterBySetAlgorithm(ctx *AlterBySetAlgorithmContext) {} + +// ExitAlterBySetAlgorithm is called when production alterBySetAlgorithm is exited. +func (s *BaseMySqlParserListener) ExitAlterBySetAlgorithm(ctx *AlterBySetAlgorithmContext) {} + +// EnterAlterByChangeDefault is called when production alterByChangeDefault is entered. +func (s *BaseMySqlParserListener) EnterAlterByChangeDefault(ctx *AlterByChangeDefaultContext) {} + +// ExitAlterByChangeDefault is called when production alterByChangeDefault is exited. +func (s *BaseMySqlParserListener) ExitAlterByChangeDefault(ctx *AlterByChangeDefaultContext) {} + +// EnterAlterByChangeColumn is called when production alterByChangeColumn is entered. +func (s *BaseMySqlParserListener) EnterAlterByChangeColumn(ctx *AlterByChangeColumnContext) {} + +// ExitAlterByChangeColumn is called when production alterByChangeColumn is exited. +func (s *BaseMySqlParserListener) ExitAlterByChangeColumn(ctx *AlterByChangeColumnContext) {} + +// EnterAlterByRenameColumn is called when production alterByRenameColumn is entered. +func (s *BaseMySqlParserListener) EnterAlterByRenameColumn(ctx *AlterByRenameColumnContext) {} + +// ExitAlterByRenameColumn is called when production alterByRenameColumn is exited. +func (s *BaseMySqlParserListener) ExitAlterByRenameColumn(ctx *AlterByRenameColumnContext) {} + +// EnterAlterByLock is called when production alterByLock is entered. +func (s *BaseMySqlParserListener) EnterAlterByLock(ctx *AlterByLockContext) {} + +// ExitAlterByLock is called when production alterByLock is exited. +func (s *BaseMySqlParserListener) ExitAlterByLock(ctx *AlterByLockContext) {} + +// EnterAlterByModifyColumn is called when production alterByModifyColumn is entered. +func (s *BaseMySqlParserListener) EnterAlterByModifyColumn(ctx *AlterByModifyColumnContext) {} + +// ExitAlterByModifyColumn is called when production alterByModifyColumn is exited. +func (s *BaseMySqlParserListener) ExitAlterByModifyColumn(ctx *AlterByModifyColumnContext) {} + +// EnterAlterByDropColumn is called when production alterByDropColumn is entered. +func (s *BaseMySqlParserListener) EnterAlterByDropColumn(ctx *AlterByDropColumnContext) {} + +// ExitAlterByDropColumn is called when production alterByDropColumn is exited. +func (s *BaseMySqlParserListener) ExitAlterByDropColumn(ctx *AlterByDropColumnContext) {} + +// EnterAlterByDropConstraintCheck is called when production alterByDropConstraintCheck is entered. +func (s *BaseMySqlParserListener) EnterAlterByDropConstraintCheck(ctx *AlterByDropConstraintCheckContext) { +} + +// ExitAlterByDropConstraintCheck is called when production alterByDropConstraintCheck is exited. +func (s *BaseMySqlParserListener) ExitAlterByDropConstraintCheck(ctx *AlterByDropConstraintCheckContext) { +} + +// EnterAlterByDropPrimaryKey is called when production alterByDropPrimaryKey is entered. +func (s *BaseMySqlParserListener) EnterAlterByDropPrimaryKey(ctx *AlterByDropPrimaryKeyContext) {} + +// ExitAlterByDropPrimaryKey is called when production alterByDropPrimaryKey is exited. +func (s *BaseMySqlParserListener) ExitAlterByDropPrimaryKey(ctx *AlterByDropPrimaryKeyContext) {} + +// EnterAlterByDropIndex is called when production alterByDropIndex is entered. +func (s *BaseMySqlParserListener) EnterAlterByDropIndex(ctx *AlterByDropIndexContext) {} + +// ExitAlterByDropIndex is called when production alterByDropIndex is exited. +func (s *BaseMySqlParserListener) ExitAlterByDropIndex(ctx *AlterByDropIndexContext) {} + +// EnterAlterByRenameIndex is called when production alterByRenameIndex is entered. +func (s *BaseMySqlParserListener) EnterAlterByRenameIndex(ctx *AlterByRenameIndexContext) {} + +// ExitAlterByRenameIndex is called when production alterByRenameIndex is exited. +func (s *BaseMySqlParserListener) ExitAlterByRenameIndex(ctx *AlterByRenameIndexContext) {} + +// EnterAlterByAlterColumnDefault is called when production alterByAlterColumnDefault is entered. +func (s *BaseMySqlParserListener) EnterAlterByAlterColumnDefault(ctx *AlterByAlterColumnDefaultContext) { +} + +// ExitAlterByAlterColumnDefault is called when production alterByAlterColumnDefault is exited. +func (s *BaseMySqlParserListener) ExitAlterByAlterColumnDefault(ctx *AlterByAlterColumnDefaultContext) { +} + +// EnterAlterByAlterIndexVisibility is called when production alterByAlterIndexVisibility is entered. +func (s *BaseMySqlParserListener) EnterAlterByAlterIndexVisibility(ctx *AlterByAlterIndexVisibilityContext) { +} + +// ExitAlterByAlterIndexVisibility is called when production alterByAlterIndexVisibility is exited. +func (s *BaseMySqlParserListener) ExitAlterByAlterIndexVisibility(ctx *AlterByAlterIndexVisibilityContext) { +} + +// EnterAlterByDropForeignKey is called when production alterByDropForeignKey is entered. +func (s *BaseMySqlParserListener) EnterAlterByDropForeignKey(ctx *AlterByDropForeignKeyContext) {} + +// ExitAlterByDropForeignKey is called when production alterByDropForeignKey is exited. +func (s *BaseMySqlParserListener) ExitAlterByDropForeignKey(ctx *AlterByDropForeignKeyContext) {} + +// EnterAlterByDisableKeys is called when production alterByDisableKeys is entered. +func (s *BaseMySqlParserListener) EnterAlterByDisableKeys(ctx *AlterByDisableKeysContext) {} + +// ExitAlterByDisableKeys is called when production alterByDisableKeys is exited. +func (s *BaseMySqlParserListener) ExitAlterByDisableKeys(ctx *AlterByDisableKeysContext) {} + +// EnterAlterByEnableKeys is called when production alterByEnableKeys is entered. +func (s *BaseMySqlParserListener) EnterAlterByEnableKeys(ctx *AlterByEnableKeysContext) {} + +// ExitAlterByEnableKeys is called when production alterByEnableKeys is exited. +func (s *BaseMySqlParserListener) ExitAlterByEnableKeys(ctx *AlterByEnableKeysContext) {} + +// EnterAlterByRename is called when production alterByRename is entered. +func (s *BaseMySqlParserListener) EnterAlterByRename(ctx *AlterByRenameContext) {} + +// ExitAlterByRename is called when production alterByRename is exited. +func (s *BaseMySqlParserListener) ExitAlterByRename(ctx *AlterByRenameContext) {} + +// EnterAlterByOrder is called when production alterByOrder is entered. +func (s *BaseMySqlParserListener) EnterAlterByOrder(ctx *AlterByOrderContext) {} + +// ExitAlterByOrder is called when production alterByOrder is exited. +func (s *BaseMySqlParserListener) ExitAlterByOrder(ctx *AlterByOrderContext) {} + +// EnterAlterByConvertCharset is called when production alterByConvertCharset is entered. +func (s *BaseMySqlParserListener) EnterAlterByConvertCharset(ctx *AlterByConvertCharsetContext) {} + +// ExitAlterByConvertCharset is called when production alterByConvertCharset is exited. +func (s *BaseMySqlParserListener) ExitAlterByConvertCharset(ctx *AlterByConvertCharsetContext) {} + +// EnterAlterByDefaultCharset is called when production alterByDefaultCharset is entered. +func (s *BaseMySqlParserListener) EnterAlterByDefaultCharset(ctx *AlterByDefaultCharsetContext) {} + +// ExitAlterByDefaultCharset is called when production alterByDefaultCharset is exited. +func (s *BaseMySqlParserListener) ExitAlterByDefaultCharset(ctx *AlterByDefaultCharsetContext) {} + +// EnterAlterByDiscardTablespace is called when production alterByDiscardTablespace is entered. +func (s *BaseMySqlParserListener) EnterAlterByDiscardTablespace(ctx *AlterByDiscardTablespaceContext) { +} + +// ExitAlterByDiscardTablespace is called when production alterByDiscardTablespace is exited. +func (s *BaseMySqlParserListener) ExitAlterByDiscardTablespace(ctx *AlterByDiscardTablespaceContext) { +} + +// EnterAlterByImportTablespace is called when production alterByImportTablespace is entered. +func (s *BaseMySqlParserListener) EnterAlterByImportTablespace(ctx *AlterByImportTablespaceContext) {} + +// ExitAlterByImportTablespace is called when production alterByImportTablespace is exited. +func (s *BaseMySqlParserListener) ExitAlterByImportTablespace(ctx *AlterByImportTablespaceContext) {} + +// EnterAlterByForce is called when production alterByForce is entered. +func (s *BaseMySqlParserListener) EnterAlterByForce(ctx *AlterByForceContext) {} + +// ExitAlterByForce is called when production alterByForce is exited. +func (s *BaseMySqlParserListener) ExitAlterByForce(ctx *AlterByForceContext) {} + +// EnterAlterByValidate is called when production alterByValidate is entered. +func (s *BaseMySqlParserListener) EnterAlterByValidate(ctx *AlterByValidateContext) {} + +// ExitAlterByValidate is called when production alterByValidate is exited. +func (s *BaseMySqlParserListener) ExitAlterByValidate(ctx *AlterByValidateContext) {} + +// EnterAlterByAddDefinitions is called when production alterByAddDefinitions is entered. +func (s *BaseMySqlParserListener) EnterAlterByAddDefinitions(ctx *AlterByAddDefinitionsContext) {} + +// ExitAlterByAddDefinitions is called when production alterByAddDefinitions is exited. +func (s *BaseMySqlParserListener) ExitAlterByAddDefinitions(ctx *AlterByAddDefinitionsContext) {} + +// EnterAlterPartition is called when production alterPartition is entered. +func (s *BaseMySqlParserListener) EnterAlterPartition(ctx *AlterPartitionContext) {} + +// ExitAlterPartition is called when production alterPartition is exited. +func (s *BaseMySqlParserListener) ExitAlterPartition(ctx *AlterPartitionContext) {} + +// EnterAlterByAddPartition is called when production alterByAddPartition is entered. +func (s *BaseMySqlParserListener) EnterAlterByAddPartition(ctx *AlterByAddPartitionContext) {} + +// ExitAlterByAddPartition is called when production alterByAddPartition is exited. +func (s *BaseMySqlParserListener) ExitAlterByAddPartition(ctx *AlterByAddPartitionContext) {} + +// EnterAlterByDropPartition is called when production alterByDropPartition is entered. +func (s *BaseMySqlParserListener) EnterAlterByDropPartition(ctx *AlterByDropPartitionContext) {} + +// ExitAlterByDropPartition is called when production alterByDropPartition is exited. +func (s *BaseMySqlParserListener) ExitAlterByDropPartition(ctx *AlterByDropPartitionContext) {} + +// EnterAlterByDiscardPartition is called when production alterByDiscardPartition is entered. +func (s *BaseMySqlParserListener) EnterAlterByDiscardPartition(ctx *AlterByDiscardPartitionContext) {} + +// ExitAlterByDiscardPartition is called when production alterByDiscardPartition is exited. +func (s *BaseMySqlParserListener) ExitAlterByDiscardPartition(ctx *AlterByDiscardPartitionContext) {} + +// EnterAlterByImportPartition is called when production alterByImportPartition is entered. +func (s *BaseMySqlParserListener) EnterAlterByImportPartition(ctx *AlterByImportPartitionContext) {} + +// ExitAlterByImportPartition is called when production alterByImportPartition is exited. +func (s *BaseMySqlParserListener) ExitAlterByImportPartition(ctx *AlterByImportPartitionContext) {} + +// EnterAlterByTruncatePartition is called when production alterByTruncatePartition is entered. +func (s *BaseMySqlParserListener) EnterAlterByTruncatePartition(ctx *AlterByTruncatePartitionContext) { +} + +// ExitAlterByTruncatePartition is called when production alterByTruncatePartition is exited. +func (s *BaseMySqlParserListener) ExitAlterByTruncatePartition(ctx *AlterByTruncatePartitionContext) { +} + +// EnterAlterByCoalescePartition is called when production alterByCoalescePartition is entered. +func (s *BaseMySqlParserListener) EnterAlterByCoalescePartition(ctx *AlterByCoalescePartitionContext) { +} + +// ExitAlterByCoalescePartition is called when production alterByCoalescePartition is exited. +func (s *BaseMySqlParserListener) ExitAlterByCoalescePartition(ctx *AlterByCoalescePartitionContext) { +} + +// EnterAlterByReorganizePartition is called when production alterByReorganizePartition is entered. +func (s *BaseMySqlParserListener) EnterAlterByReorganizePartition(ctx *AlterByReorganizePartitionContext) { +} + +// ExitAlterByReorganizePartition is called when production alterByReorganizePartition is exited. +func (s *BaseMySqlParserListener) ExitAlterByReorganizePartition(ctx *AlterByReorganizePartitionContext) { +} + +// EnterAlterByExchangePartition is called when production alterByExchangePartition is entered. +func (s *BaseMySqlParserListener) EnterAlterByExchangePartition(ctx *AlterByExchangePartitionContext) { +} + +// ExitAlterByExchangePartition is called when production alterByExchangePartition is exited. +func (s *BaseMySqlParserListener) ExitAlterByExchangePartition(ctx *AlterByExchangePartitionContext) { +} + +// EnterAlterByAnalyzePartition is called when production alterByAnalyzePartition is entered. +func (s *BaseMySqlParserListener) EnterAlterByAnalyzePartition(ctx *AlterByAnalyzePartitionContext) {} + +// ExitAlterByAnalyzePartition is called when production alterByAnalyzePartition is exited. +func (s *BaseMySqlParserListener) ExitAlterByAnalyzePartition(ctx *AlterByAnalyzePartitionContext) {} + +// EnterAlterByCheckPartition is called when production alterByCheckPartition is entered. +func (s *BaseMySqlParserListener) EnterAlterByCheckPartition(ctx *AlterByCheckPartitionContext) {} + +// ExitAlterByCheckPartition is called when production alterByCheckPartition is exited. +func (s *BaseMySqlParserListener) ExitAlterByCheckPartition(ctx *AlterByCheckPartitionContext) {} + +// EnterAlterByOptimizePartition is called when production alterByOptimizePartition is entered. +func (s *BaseMySqlParserListener) EnterAlterByOptimizePartition(ctx *AlterByOptimizePartitionContext) { +} + +// ExitAlterByOptimizePartition is called when production alterByOptimizePartition is exited. +func (s *BaseMySqlParserListener) ExitAlterByOptimizePartition(ctx *AlterByOptimizePartitionContext) { +} + +// EnterAlterByRebuildPartition is called when production alterByRebuildPartition is entered. +func (s *BaseMySqlParserListener) EnterAlterByRebuildPartition(ctx *AlterByRebuildPartitionContext) {} + +// ExitAlterByRebuildPartition is called when production alterByRebuildPartition is exited. +func (s *BaseMySqlParserListener) ExitAlterByRebuildPartition(ctx *AlterByRebuildPartitionContext) {} + +// EnterAlterByRepairPartition is called when production alterByRepairPartition is entered. +func (s *BaseMySqlParserListener) EnterAlterByRepairPartition(ctx *AlterByRepairPartitionContext) {} + +// ExitAlterByRepairPartition is called when production alterByRepairPartition is exited. +func (s *BaseMySqlParserListener) ExitAlterByRepairPartition(ctx *AlterByRepairPartitionContext) {} + +// EnterAlterByRemovePartitioning is called when production alterByRemovePartitioning is entered. +func (s *BaseMySqlParserListener) EnterAlterByRemovePartitioning(ctx *AlterByRemovePartitioningContext) { +} + +// ExitAlterByRemovePartitioning is called when production alterByRemovePartitioning is exited. +func (s *BaseMySqlParserListener) ExitAlterByRemovePartitioning(ctx *AlterByRemovePartitioningContext) { +} + +// EnterAlterByUpgradePartitioning is called when production alterByUpgradePartitioning is entered. +func (s *BaseMySqlParserListener) EnterAlterByUpgradePartitioning(ctx *AlterByUpgradePartitioningContext) { +} + +// ExitAlterByUpgradePartitioning is called when production alterByUpgradePartitioning is exited. +func (s *BaseMySqlParserListener) ExitAlterByUpgradePartitioning(ctx *AlterByUpgradePartitioningContext) { +} + +// EnterDropDatabase is called when production dropDatabase is entered. +func (s *BaseMySqlParserListener) EnterDropDatabase(ctx *DropDatabaseContext) {} + +// ExitDropDatabase is called when production dropDatabase is exited. +func (s *BaseMySqlParserListener) ExitDropDatabase(ctx *DropDatabaseContext) {} + +// EnterDropEvent is called when production dropEvent is entered. +func (s *BaseMySqlParserListener) EnterDropEvent(ctx *DropEventContext) {} + +// ExitDropEvent is called when production dropEvent is exited. +func (s *BaseMySqlParserListener) ExitDropEvent(ctx *DropEventContext) {} + +// EnterDropIndex is called when production dropIndex is entered. +func (s *BaseMySqlParserListener) EnterDropIndex(ctx *DropIndexContext) {} + +// ExitDropIndex is called when production dropIndex is exited. +func (s *BaseMySqlParserListener) ExitDropIndex(ctx *DropIndexContext) {} + +// EnterDropLogfileGroup is called when production dropLogfileGroup is entered. +func (s *BaseMySqlParserListener) EnterDropLogfileGroup(ctx *DropLogfileGroupContext) {} + +// ExitDropLogfileGroup is called when production dropLogfileGroup is exited. +func (s *BaseMySqlParserListener) ExitDropLogfileGroup(ctx *DropLogfileGroupContext) {} + +// EnterDropProcedure is called when production dropProcedure is entered. +func (s *BaseMySqlParserListener) EnterDropProcedure(ctx *DropProcedureContext) {} + +// ExitDropProcedure is called when production dropProcedure is exited. +func (s *BaseMySqlParserListener) ExitDropProcedure(ctx *DropProcedureContext) {} + +// EnterDropFunction is called when production dropFunction is entered. +func (s *BaseMySqlParserListener) EnterDropFunction(ctx *DropFunctionContext) {} + +// ExitDropFunction is called when production dropFunction is exited. +func (s *BaseMySqlParserListener) ExitDropFunction(ctx *DropFunctionContext) {} + +// EnterDropServer is called when production dropServer is entered. +func (s *BaseMySqlParserListener) EnterDropServer(ctx *DropServerContext) {} + +// ExitDropServer is called when production dropServer is exited. +func (s *BaseMySqlParserListener) ExitDropServer(ctx *DropServerContext) {} + +// EnterDropTable is called when production dropTable is entered. +func (s *BaseMySqlParserListener) EnterDropTable(ctx *DropTableContext) {} + +// ExitDropTable is called when production dropTable is exited. +func (s *BaseMySqlParserListener) ExitDropTable(ctx *DropTableContext) {} + +// EnterDropTablespace is called when production dropTablespace is entered. +func (s *BaseMySqlParserListener) EnterDropTablespace(ctx *DropTablespaceContext) {} + +// ExitDropTablespace is called when production dropTablespace is exited. +func (s *BaseMySqlParserListener) ExitDropTablespace(ctx *DropTablespaceContext) {} + +// EnterDropTrigger is called when production dropTrigger is entered. +func (s *BaseMySqlParserListener) EnterDropTrigger(ctx *DropTriggerContext) {} + +// ExitDropTrigger is called when production dropTrigger is exited. +func (s *BaseMySqlParserListener) ExitDropTrigger(ctx *DropTriggerContext) {} + +// EnterDropView is called when production dropView is entered. +func (s *BaseMySqlParserListener) EnterDropView(ctx *DropViewContext) {} + +// ExitDropView is called when production dropView is exited. +func (s *BaseMySqlParserListener) ExitDropView(ctx *DropViewContext) {} + +// EnterDropRole is called when production dropRole is entered. +func (s *BaseMySqlParserListener) EnterDropRole(ctx *DropRoleContext) {} + +// ExitDropRole is called when production dropRole is exited. +func (s *BaseMySqlParserListener) ExitDropRole(ctx *DropRoleContext) {} + +// EnterSetRole is called when production setRole is entered. +func (s *BaseMySqlParserListener) EnterSetRole(ctx *SetRoleContext) {} + +// ExitSetRole is called when production setRole is exited. +func (s *BaseMySqlParserListener) ExitSetRole(ctx *SetRoleContext) {} + +// EnterRenameTable is called when production renameTable is entered. +func (s *BaseMySqlParserListener) EnterRenameTable(ctx *RenameTableContext) {} + +// ExitRenameTable is called when production renameTable is exited. +func (s *BaseMySqlParserListener) ExitRenameTable(ctx *RenameTableContext) {} + +// EnterRenameTableClause is called when production renameTableClause is entered. +func (s *BaseMySqlParserListener) EnterRenameTableClause(ctx *RenameTableClauseContext) {} + +// ExitRenameTableClause is called when production renameTableClause is exited. +func (s *BaseMySqlParserListener) ExitRenameTableClause(ctx *RenameTableClauseContext) {} + +// EnterTruncateTable is called when production truncateTable is entered. +func (s *BaseMySqlParserListener) EnterTruncateTable(ctx *TruncateTableContext) {} + +// ExitTruncateTable is called when production truncateTable is exited. +func (s *BaseMySqlParserListener) ExitTruncateTable(ctx *TruncateTableContext) {} + +// EnterCallStatement is called when production callStatement is entered. +func (s *BaseMySqlParserListener) EnterCallStatement(ctx *CallStatementContext) {} + +// ExitCallStatement is called when production callStatement is exited. +func (s *BaseMySqlParserListener) ExitCallStatement(ctx *CallStatementContext) {} + +// EnterDeleteStatement is called when production deleteStatement is entered. +func (s *BaseMySqlParserListener) EnterDeleteStatement(ctx *DeleteStatementContext) {} + +// ExitDeleteStatement is called when production deleteStatement is exited. +func (s *BaseMySqlParserListener) ExitDeleteStatement(ctx *DeleteStatementContext) {} + +// EnterDoStatement is called when production doStatement is entered. +func (s *BaseMySqlParserListener) EnterDoStatement(ctx *DoStatementContext) {} + +// ExitDoStatement is called when production doStatement is exited. +func (s *BaseMySqlParserListener) ExitDoStatement(ctx *DoStatementContext) {} + +// EnterHandlerStatement is called when production handlerStatement is entered. +func (s *BaseMySqlParserListener) EnterHandlerStatement(ctx *HandlerStatementContext) {} + +// ExitHandlerStatement is called when production handlerStatement is exited. +func (s *BaseMySqlParserListener) ExitHandlerStatement(ctx *HandlerStatementContext) {} + +// EnterInsertStatement is called when production insertStatement is entered. +func (s *BaseMySqlParserListener) EnterInsertStatement(ctx *InsertStatementContext) {} + +// ExitInsertStatement is called when production insertStatement is exited. +func (s *BaseMySqlParserListener) ExitInsertStatement(ctx *InsertStatementContext) {} + +// EnterLoadDataStatement is called when production loadDataStatement is entered. +func (s *BaseMySqlParserListener) EnterLoadDataStatement(ctx *LoadDataStatementContext) {} + +// ExitLoadDataStatement is called when production loadDataStatement is exited. +func (s *BaseMySqlParserListener) ExitLoadDataStatement(ctx *LoadDataStatementContext) {} + +// EnterLoadXmlStatement is called when production loadXmlStatement is entered. +func (s *BaseMySqlParserListener) EnterLoadXmlStatement(ctx *LoadXmlStatementContext) {} + +// ExitLoadXmlStatement is called when production loadXmlStatement is exited. +func (s *BaseMySqlParserListener) ExitLoadXmlStatement(ctx *LoadXmlStatementContext) {} + +// EnterReplaceStatement is called when production replaceStatement is entered. +func (s *BaseMySqlParserListener) EnterReplaceStatement(ctx *ReplaceStatementContext) {} + +// ExitReplaceStatement is called when production replaceStatement is exited. +func (s *BaseMySqlParserListener) ExitReplaceStatement(ctx *ReplaceStatementContext) {} + +// EnterSimpleSelect is called when production simpleSelect is entered. +func (s *BaseMySqlParserListener) EnterSimpleSelect(ctx *SimpleSelectContext) {} + +// ExitSimpleSelect is called when production simpleSelect is exited. +func (s *BaseMySqlParserListener) ExitSimpleSelect(ctx *SimpleSelectContext) {} + +// EnterParenthesisSelect is called when production parenthesisSelect is entered. +func (s *BaseMySqlParserListener) EnterParenthesisSelect(ctx *ParenthesisSelectContext) {} + +// ExitParenthesisSelect is called when production parenthesisSelect is exited. +func (s *BaseMySqlParserListener) ExitParenthesisSelect(ctx *ParenthesisSelectContext) {} + +// EnterUnionSelect is called when production unionSelect is entered. +func (s *BaseMySqlParserListener) EnterUnionSelect(ctx *UnionSelectContext) {} + +// ExitUnionSelect is called when production unionSelect is exited. +func (s *BaseMySqlParserListener) ExitUnionSelect(ctx *UnionSelectContext) {} + +// EnterUnionParenthesisSelect is called when production unionParenthesisSelect is entered. +func (s *BaseMySqlParserListener) EnterUnionParenthesisSelect(ctx *UnionParenthesisSelectContext) {} + +// ExitUnionParenthesisSelect is called when production unionParenthesisSelect is exited. +func (s *BaseMySqlParserListener) ExitUnionParenthesisSelect(ctx *UnionParenthesisSelectContext) {} + +// EnterWithLateralStatement is called when production withLateralStatement is entered. +func (s *BaseMySqlParserListener) EnterWithLateralStatement(ctx *WithLateralStatementContext) {} + +// ExitWithLateralStatement is called when production withLateralStatement is exited. +func (s *BaseMySqlParserListener) ExitWithLateralStatement(ctx *WithLateralStatementContext) {} + +// EnterUpdateStatement is called when production updateStatement is entered. +func (s *BaseMySqlParserListener) EnterUpdateStatement(ctx *UpdateStatementContext) {} + +// ExitUpdateStatement is called when production updateStatement is exited. +func (s *BaseMySqlParserListener) ExitUpdateStatement(ctx *UpdateStatementContext) {} + +// EnterValuesStatement is called when production valuesStatement is entered. +func (s *BaseMySqlParserListener) EnterValuesStatement(ctx *ValuesStatementContext) {} + +// ExitValuesStatement is called when production valuesStatement is exited. +func (s *BaseMySqlParserListener) ExitValuesStatement(ctx *ValuesStatementContext) {} + +// EnterInsertStatementValue is called when production insertStatementValue is entered. +func (s *BaseMySqlParserListener) EnterInsertStatementValue(ctx *InsertStatementValueContext) {} + +// ExitInsertStatementValue is called when production insertStatementValue is exited. +func (s *BaseMySqlParserListener) ExitInsertStatementValue(ctx *InsertStatementValueContext) {} + +// EnterUpdatedElement is called when production updatedElement is entered. +func (s *BaseMySqlParserListener) EnterUpdatedElement(ctx *UpdatedElementContext) {} + +// ExitUpdatedElement is called when production updatedElement is exited. +func (s *BaseMySqlParserListener) ExitUpdatedElement(ctx *UpdatedElementContext) {} + +// EnterAssignmentField is called when production assignmentField is entered. +func (s *BaseMySqlParserListener) EnterAssignmentField(ctx *AssignmentFieldContext) {} + +// ExitAssignmentField is called when production assignmentField is exited. +func (s *BaseMySqlParserListener) ExitAssignmentField(ctx *AssignmentFieldContext) {} + +// EnterLockClause is called when production lockClause is entered. +func (s *BaseMySqlParserListener) EnterLockClause(ctx *LockClauseContext) {} + +// ExitLockClause is called when production lockClause is exited. +func (s *BaseMySqlParserListener) ExitLockClause(ctx *LockClauseContext) {} + +// EnterSingleDeleteStatement is called when production singleDeleteStatement is entered. +func (s *BaseMySqlParserListener) EnterSingleDeleteStatement(ctx *SingleDeleteStatementContext) {} + +// ExitSingleDeleteStatement is called when production singleDeleteStatement is exited. +func (s *BaseMySqlParserListener) ExitSingleDeleteStatement(ctx *SingleDeleteStatementContext) {} + +// EnterMultipleDeleteStatement is called when production multipleDeleteStatement is entered. +func (s *BaseMySqlParserListener) EnterMultipleDeleteStatement(ctx *MultipleDeleteStatementContext) {} + +// ExitMultipleDeleteStatement is called when production multipleDeleteStatement is exited. +func (s *BaseMySqlParserListener) ExitMultipleDeleteStatement(ctx *MultipleDeleteStatementContext) {} + +// EnterHandlerOpenStatement is called when production handlerOpenStatement is entered. +func (s *BaseMySqlParserListener) EnterHandlerOpenStatement(ctx *HandlerOpenStatementContext) {} + +// ExitHandlerOpenStatement is called when production handlerOpenStatement is exited. +func (s *BaseMySqlParserListener) ExitHandlerOpenStatement(ctx *HandlerOpenStatementContext) {} + +// EnterHandlerReadIndexStatement is called when production handlerReadIndexStatement is entered. +func (s *BaseMySqlParserListener) EnterHandlerReadIndexStatement(ctx *HandlerReadIndexStatementContext) { +} + +// ExitHandlerReadIndexStatement is called when production handlerReadIndexStatement is exited. +func (s *BaseMySqlParserListener) ExitHandlerReadIndexStatement(ctx *HandlerReadIndexStatementContext) { +} + +// EnterHandlerReadStatement is called when production handlerReadStatement is entered. +func (s *BaseMySqlParserListener) EnterHandlerReadStatement(ctx *HandlerReadStatementContext) {} + +// ExitHandlerReadStatement is called when production handlerReadStatement is exited. +func (s *BaseMySqlParserListener) ExitHandlerReadStatement(ctx *HandlerReadStatementContext) {} + +// EnterHandlerCloseStatement is called when production handlerCloseStatement is entered. +func (s *BaseMySqlParserListener) EnterHandlerCloseStatement(ctx *HandlerCloseStatementContext) {} + +// ExitHandlerCloseStatement is called when production handlerCloseStatement is exited. +func (s *BaseMySqlParserListener) ExitHandlerCloseStatement(ctx *HandlerCloseStatementContext) {} + +// EnterSingleUpdateStatement is called when production singleUpdateStatement is entered. +func (s *BaseMySqlParserListener) EnterSingleUpdateStatement(ctx *SingleUpdateStatementContext) {} + +// ExitSingleUpdateStatement is called when production singleUpdateStatement is exited. +func (s *BaseMySqlParserListener) ExitSingleUpdateStatement(ctx *SingleUpdateStatementContext) {} + +// EnterMultipleUpdateStatement is called when production multipleUpdateStatement is entered. +func (s *BaseMySqlParserListener) EnterMultipleUpdateStatement(ctx *MultipleUpdateStatementContext) {} + +// ExitMultipleUpdateStatement is called when production multipleUpdateStatement is exited. +func (s *BaseMySqlParserListener) ExitMultipleUpdateStatement(ctx *MultipleUpdateStatementContext) {} + +// EnterOrderByClause is called when production orderByClause is entered. +func (s *BaseMySqlParserListener) EnterOrderByClause(ctx *OrderByClauseContext) {} + +// ExitOrderByClause is called when production orderByClause is exited. +func (s *BaseMySqlParserListener) ExitOrderByClause(ctx *OrderByClauseContext) {} + +// EnterOrderByExpression is called when production orderByExpression is entered. +func (s *BaseMySqlParserListener) EnterOrderByExpression(ctx *OrderByExpressionContext) {} + +// ExitOrderByExpression is called when production orderByExpression is exited. +func (s *BaseMySqlParserListener) ExitOrderByExpression(ctx *OrderByExpressionContext) {} + +// EnterTableSources is called when production tableSources is entered. +func (s *BaseMySqlParserListener) EnterTableSources(ctx *TableSourcesContext) {} + +// ExitTableSources is called when production tableSources is exited. +func (s *BaseMySqlParserListener) ExitTableSources(ctx *TableSourcesContext) {} + +// EnterTableSourceBase is called when production tableSourceBase is entered. +func (s *BaseMySqlParserListener) EnterTableSourceBase(ctx *TableSourceBaseContext) {} + +// ExitTableSourceBase is called when production tableSourceBase is exited. +func (s *BaseMySqlParserListener) ExitTableSourceBase(ctx *TableSourceBaseContext) {} + +// EnterTableSourceNested is called when production tableSourceNested is entered. +func (s *BaseMySqlParserListener) EnterTableSourceNested(ctx *TableSourceNestedContext) {} + +// ExitTableSourceNested is called when production tableSourceNested is exited. +func (s *BaseMySqlParserListener) ExitTableSourceNested(ctx *TableSourceNestedContext) {} + +// EnterTableJson is called when production tableJson is entered. +func (s *BaseMySqlParserListener) EnterTableJson(ctx *TableJsonContext) {} + +// ExitTableJson is called when production tableJson is exited. +func (s *BaseMySqlParserListener) ExitTableJson(ctx *TableJsonContext) {} + +// EnterAtomTableItem is called when production atomTableItem is entered. +func (s *BaseMySqlParserListener) EnterAtomTableItem(ctx *AtomTableItemContext) {} + +// ExitAtomTableItem is called when production atomTableItem is exited. +func (s *BaseMySqlParserListener) ExitAtomTableItem(ctx *AtomTableItemContext) {} + +// EnterSubqueryTableItem is called when production subqueryTableItem is entered. +func (s *BaseMySqlParserListener) EnterSubqueryTableItem(ctx *SubqueryTableItemContext) {} + +// ExitSubqueryTableItem is called when production subqueryTableItem is exited. +func (s *BaseMySqlParserListener) ExitSubqueryTableItem(ctx *SubqueryTableItemContext) {} + +// EnterTableSourcesItem is called when production tableSourcesItem is entered. +func (s *BaseMySqlParserListener) EnterTableSourcesItem(ctx *TableSourcesItemContext) {} + +// ExitTableSourcesItem is called when production tableSourcesItem is exited. +func (s *BaseMySqlParserListener) ExitTableSourcesItem(ctx *TableSourcesItemContext) {} + +// EnterIndexHint is called when production indexHint is entered. +func (s *BaseMySqlParserListener) EnterIndexHint(ctx *IndexHintContext) {} + +// ExitIndexHint is called when production indexHint is exited. +func (s *BaseMySqlParserListener) ExitIndexHint(ctx *IndexHintContext) {} + +// EnterIndexHintType is called when production indexHintType is entered. +func (s *BaseMySqlParserListener) EnterIndexHintType(ctx *IndexHintTypeContext) {} + +// ExitIndexHintType is called when production indexHintType is exited. +func (s *BaseMySqlParserListener) ExitIndexHintType(ctx *IndexHintTypeContext) {} + +// EnterInnerJoin is called when production innerJoin is entered. +func (s *BaseMySqlParserListener) EnterInnerJoin(ctx *InnerJoinContext) {} + +// ExitInnerJoin is called when production innerJoin is exited. +func (s *BaseMySqlParserListener) ExitInnerJoin(ctx *InnerJoinContext) {} + +// EnterStraightJoin is called when production straightJoin is entered. +func (s *BaseMySqlParserListener) EnterStraightJoin(ctx *StraightJoinContext) {} + +// ExitStraightJoin is called when production straightJoin is exited. +func (s *BaseMySqlParserListener) ExitStraightJoin(ctx *StraightJoinContext) {} + +// EnterOuterJoin is called when production outerJoin is entered. +func (s *BaseMySqlParserListener) EnterOuterJoin(ctx *OuterJoinContext) {} + +// ExitOuterJoin is called when production outerJoin is exited. +func (s *BaseMySqlParserListener) ExitOuterJoin(ctx *OuterJoinContext) {} + +// EnterNaturalJoin is called when production naturalJoin is entered. +func (s *BaseMySqlParserListener) EnterNaturalJoin(ctx *NaturalJoinContext) {} + +// ExitNaturalJoin is called when production naturalJoin is exited. +func (s *BaseMySqlParserListener) ExitNaturalJoin(ctx *NaturalJoinContext) {} + +// EnterJoinSpec is called when production joinSpec is entered. +func (s *BaseMySqlParserListener) EnterJoinSpec(ctx *JoinSpecContext) {} + +// ExitJoinSpec is called when production joinSpec is exited. +func (s *BaseMySqlParserListener) ExitJoinSpec(ctx *JoinSpecContext) {} + +// EnterQueryExpression is called when production queryExpression is entered. +func (s *BaseMySqlParserListener) EnterQueryExpression(ctx *QueryExpressionContext) {} + +// ExitQueryExpression is called when production queryExpression is exited. +func (s *BaseMySqlParserListener) ExitQueryExpression(ctx *QueryExpressionContext) {} + +// EnterQueryExpressionNointo is called when production queryExpressionNointo is entered. +func (s *BaseMySqlParserListener) EnterQueryExpressionNointo(ctx *QueryExpressionNointoContext) {} + +// ExitQueryExpressionNointo is called when production queryExpressionNointo is exited. +func (s *BaseMySqlParserListener) ExitQueryExpressionNointo(ctx *QueryExpressionNointoContext) {} + +// EnterQuerySpecification is called when production querySpecification is entered. +func (s *BaseMySqlParserListener) EnterQuerySpecification(ctx *QuerySpecificationContext) {} + +// ExitQuerySpecification is called when production querySpecification is exited. +func (s *BaseMySqlParserListener) ExitQuerySpecification(ctx *QuerySpecificationContext) {} + +// EnterQuerySpecificationNointo is called when production querySpecificationNointo is entered. +func (s *BaseMySqlParserListener) EnterQuerySpecificationNointo(ctx *QuerySpecificationNointoContext) { +} + +// ExitQuerySpecificationNointo is called when production querySpecificationNointo is exited. +func (s *BaseMySqlParserListener) ExitQuerySpecificationNointo(ctx *QuerySpecificationNointoContext) { +} + +// EnterUnionParenthesis is called when production unionParenthesis is entered. +func (s *BaseMySqlParserListener) EnterUnionParenthesis(ctx *UnionParenthesisContext) {} + +// ExitUnionParenthesis is called when production unionParenthesis is exited. +func (s *BaseMySqlParserListener) ExitUnionParenthesis(ctx *UnionParenthesisContext) {} + +// EnterUnionStatement is called when production unionStatement is entered. +func (s *BaseMySqlParserListener) EnterUnionStatement(ctx *UnionStatementContext) {} + +// ExitUnionStatement is called when production unionStatement is exited. +func (s *BaseMySqlParserListener) ExitUnionStatement(ctx *UnionStatementContext) {} + +// EnterLateralStatement is called when production lateralStatement is entered. +func (s *BaseMySqlParserListener) EnterLateralStatement(ctx *LateralStatementContext) {} + +// ExitLateralStatement is called when production lateralStatement is exited. +func (s *BaseMySqlParserListener) ExitLateralStatement(ctx *LateralStatementContext) {} + +// EnterJsonTable is called when production jsonTable is entered. +func (s *BaseMySqlParserListener) EnterJsonTable(ctx *JsonTableContext) {} + +// ExitJsonTable is called when production jsonTable is exited. +func (s *BaseMySqlParserListener) ExitJsonTable(ctx *JsonTableContext) {} + +// EnterJsonColumnList is called when production jsonColumnList is entered. +func (s *BaseMySqlParserListener) EnterJsonColumnList(ctx *JsonColumnListContext) {} + +// ExitJsonColumnList is called when production jsonColumnList is exited. +func (s *BaseMySqlParserListener) ExitJsonColumnList(ctx *JsonColumnListContext) {} + +// EnterJsonColumn is called when production jsonColumn is entered. +func (s *BaseMySqlParserListener) EnterJsonColumn(ctx *JsonColumnContext) {} + +// ExitJsonColumn is called when production jsonColumn is exited. +func (s *BaseMySqlParserListener) ExitJsonColumn(ctx *JsonColumnContext) {} + +// EnterJsonOnEmpty is called when production jsonOnEmpty is entered. +func (s *BaseMySqlParserListener) EnterJsonOnEmpty(ctx *JsonOnEmptyContext) {} + +// ExitJsonOnEmpty is called when production jsonOnEmpty is exited. +func (s *BaseMySqlParserListener) ExitJsonOnEmpty(ctx *JsonOnEmptyContext) {} + +// EnterJsonOnError is called when production jsonOnError is entered. +func (s *BaseMySqlParserListener) EnterJsonOnError(ctx *JsonOnErrorContext) {} + +// ExitJsonOnError is called when production jsonOnError is exited. +func (s *BaseMySqlParserListener) ExitJsonOnError(ctx *JsonOnErrorContext) {} + +// EnterSelectSpec is called when production selectSpec is entered. +func (s *BaseMySqlParserListener) EnterSelectSpec(ctx *SelectSpecContext) {} + +// ExitSelectSpec is called when production selectSpec is exited. +func (s *BaseMySqlParserListener) ExitSelectSpec(ctx *SelectSpecContext) {} + +// EnterSelectElements is called when production selectElements is entered. +func (s *BaseMySqlParserListener) EnterSelectElements(ctx *SelectElementsContext) {} + +// ExitSelectElements is called when production selectElements is exited. +func (s *BaseMySqlParserListener) ExitSelectElements(ctx *SelectElementsContext) {} + +// EnterSelectStarElement is called when production selectStarElement is entered. +func (s *BaseMySqlParserListener) EnterSelectStarElement(ctx *SelectStarElementContext) {} + +// ExitSelectStarElement is called when production selectStarElement is exited. +func (s *BaseMySqlParserListener) ExitSelectStarElement(ctx *SelectStarElementContext) {} + +// EnterSelectColumnElement is called when production selectColumnElement is entered. +func (s *BaseMySqlParserListener) EnterSelectColumnElement(ctx *SelectColumnElementContext) {} + +// ExitSelectColumnElement is called when production selectColumnElement is exited. +func (s *BaseMySqlParserListener) ExitSelectColumnElement(ctx *SelectColumnElementContext) {} + +// EnterSelectFunctionElement is called when production selectFunctionElement is entered. +func (s *BaseMySqlParserListener) EnterSelectFunctionElement(ctx *SelectFunctionElementContext) {} + +// ExitSelectFunctionElement is called when production selectFunctionElement is exited. +func (s *BaseMySqlParserListener) ExitSelectFunctionElement(ctx *SelectFunctionElementContext) {} + +// EnterSelectExpressionElement is called when production selectExpressionElement is entered. +func (s *BaseMySqlParserListener) EnterSelectExpressionElement(ctx *SelectExpressionElementContext) {} + +// ExitSelectExpressionElement is called when production selectExpressionElement is exited. +func (s *BaseMySqlParserListener) ExitSelectExpressionElement(ctx *SelectExpressionElementContext) {} + +// EnterSelectIntoVariables is called when production selectIntoVariables is entered. +func (s *BaseMySqlParserListener) EnterSelectIntoVariables(ctx *SelectIntoVariablesContext) {} + +// ExitSelectIntoVariables is called when production selectIntoVariables is exited. +func (s *BaseMySqlParserListener) ExitSelectIntoVariables(ctx *SelectIntoVariablesContext) {} + +// EnterSelectIntoDumpFile is called when production selectIntoDumpFile is entered. +func (s *BaseMySqlParserListener) EnterSelectIntoDumpFile(ctx *SelectIntoDumpFileContext) {} + +// ExitSelectIntoDumpFile is called when production selectIntoDumpFile is exited. +func (s *BaseMySqlParserListener) ExitSelectIntoDumpFile(ctx *SelectIntoDumpFileContext) {} + +// EnterSelectIntoTextFile is called when production selectIntoTextFile is entered. +func (s *BaseMySqlParserListener) EnterSelectIntoTextFile(ctx *SelectIntoTextFileContext) {} + +// ExitSelectIntoTextFile is called when production selectIntoTextFile is exited. +func (s *BaseMySqlParserListener) ExitSelectIntoTextFile(ctx *SelectIntoTextFileContext) {} + +// EnterSelectFieldsInto is called when production selectFieldsInto is entered. +func (s *BaseMySqlParserListener) EnterSelectFieldsInto(ctx *SelectFieldsIntoContext) {} + +// ExitSelectFieldsInto is called when production selectFieldsInto is exited. +func (s *BaseMySqlParserListener) ExitSelectFieldsInto(ctx *SelectFieldsIntoContext) {} + +// EnterSelectLinesInto is called when production selectLinesInto is entered. +func (s *BaseMySqlParserListener) EnterSelectLinesInto(ctx *SelectLinesIntoContext) {} + +// ExitSelectLinesInto is called when production selectLinesInto is exited. +func (s *BaseMySqlParserListener) ExitSelectLinesInto(ctx *SelectLinesIntoContext) {} + +// EnterFromClause is called when production fromClause is entered. +func (s *BaseMySqlParserListener) EnterFromClause(ctx *FromClauseContext) {} + +// ExitFromClause is called when production fromClause is exited. +func (s *BaseMySqlParserListener) ExitFromClause(ctx *FromClauseContext) {} + +// EnterGroupByClause is called when production groupByClause is entered. +func (s *BaseMySqlParserListener) EnterGroupByClause(ctx *GroupByClauseContext) {} + +// ExitGroupByClause is called when production groupByClause is exited. +func (s *BaseMySqlParserListener) ExitGroupByClause(ctx *GroupByClauseContext) {} + +// EnterHavingClause is called when production havingClause is entered. +func (s *BaseMySqlParserListener) EnterHavingClause(ctx *HavingClauseContext) {} + +// ExitHavingClause is called when production havingClause is exited. +func (s *BaseMySqlParserListener) ExitHavingClause(ctx *HavingClauseContext) {} + +// EnterWindowClause is called when production windowClause is entered. +func (s *BaseMySqlParserListener) EnterWindowClause(ctx *WindowClauseContext) {} + +// ExitWindowClause is called when production windowClause is exited. +func (s *BaseMySqlParserListener) ExitWindowClause(ctx *WindowClauseContext) {} + +// EnterGroupByItem is called when production groupByItem is entered. +func (s *BaseMySqlParserListener) EnterGroupByItem(ctx *GroupByItemContext) {} + +// ExitGroupByItem is called when production groupByItem is exited. +func (s *BaseMySqlParserListener) ExitGroupByItem(ctx *GroupByItemContext) {} + +// EnterLimitClause is called when production limitClause is entered. +func (s *BaseMySqlParserListener) EnterLimitClause(ctx *LimitClauseContext) {} + +// ExitLimitClause is called when production limitClause is exited. +func (s *BaseMySqlParserListener) ExitLimitClause(ctx *LimitClauseContext) {} + +// EnterLimitClauseAtom is called when production limitClauseAtom is entered. +func (s *BaseMySqlParserListener) EnterLimitClauseAtom(ctx *LimitClauseAtomContext) {} + +// ExitLimitClauseAtom is called when production limitClauseAtom is exited. +func (s *BaseMySqlParserListener) ExitLimitClauseAtom(ctx *LimitClauseAtomContext) {} + +// EnterStartTransaction is called when production startTransaction is entered. +func (s *BaseMySqlParserListener) EnterStartTransaction(ctx *StartTransactionContext) {} + +// ExitStartTransaction is called when production startTransaction is exited. +func (s *BaseMySqlParserListener) ExitStartTransaction(ctx *StartTransactionContext) {} + +// EnterBeginWork is called when production beginWork is entered. +func (s *BaseMySqlParserListener) EnterBeginWork(ctx *BeginWorkContext) {} + +// ExitBeginWork is called when production beginWork is exited. +func (s *BaseMySqlParserListener) ExitBeginWork(ctx *BeginWorkContext) {} + +// EnterCommitWork is called when production commitWork is entered. +func (s *BaseMySqlParserListener) EnterCommitWork(ctx *CommitWorkContext) {} + +// ExitCommitWork is called when production commitWork is exited. +func (s *BaseMySqlParserListener) ExitCommitWork(ctx *CommitWorkContext) {} + +// EnterRollbackWork is called when production rollbackWork is entered. +func (s *BaseMySqlParserListener) EnterRollbackWork(ctx *RollbackWorkContext) {} + +// ExitRollbackWork is called when production rollbackWork is exited. +func (s *BaseMySqlParserListener) ExitRollbackWork(ctx *RollbackWorkContext) {} + +// EnterSavepointStatement is called when production savepointStatement is entered. +func (s *BaseMySqlParserListener) EnterSavepointStatement(ctx *SavepointStatementContext) {} + +// ExitSavepointStatement is called when production savepointStatement is exited. +func (s *BaseMySqlParserListener) ExitSavepointStatement(ctx *SavepointStatementContext) {} + +// EnterRollbackStatement is called when production rollbackStatement is entered. +func (s *BaseMySqlParserListener) EnterRollbackStatement(ctx *RollbackStatementContext) {} + +// ExitRollbackStatement is called when production rollbackStatement is exited. +func (s *BaseMySqlParserListener) ExitRollbackStatement(ctx *RollbackStatementContext) {} + +// EnterReleaseStatement is called when production releaseStatement is entered. +func (s *BaseMySqlParserListener) EnterReleaseStatement(ctx *ReleaseStatementContext) {} + +// ExitReleaseStatement is called when production releaseStatement is exited. +func (s *BaseMySqlParserListener) ExitReleaseStatement(ctx *ReleaseStatementContext) {} + +// EnterLockTables is called when production lockTables is entered. +func (s *BaseMySqlParserListener) EnterLockTables(ctx *LockTablesContext) {} + +// ExitLockTables is called when production lockTables is exited. +func (s *BaseMySqlParserListener) ExitLockTables(ctx *LockTablesContext) {} + +// EnterUnlockTables is called when production unlockTables is entered. +func (s *BaseMySqlParserListener) EnterUnlockTables(ctx *UnlockTablesContext) {} + +// ExitUnlockTables is called when production unlockTables is exited. +func (s *BaseMySqlParserListener) ExitUnlockTables(ctx *UnlockTablesContext) {} + +// EnterSetAutocommitStatement is called when production setAutocommitStatement is entered. +func (s *BaseMySqlParserListener) EnterSetAutocommitStatement(ctx *SetAutocommitStatementContext) {} + +// ExitSetAutocommitStatement is called when production setAutocommitStatement is exited. +func (s *BaseMySqlParserListener) ExitSetAutocommitStatement(ctx *SetAutocommitStatementContext) {} + +// EnterSetTransactionStatement is called when production setTransactionStatement is entered. +func (s *BaseMySqlParserListener) EnterSetTransactionStatement(ctx *SetTransactionStatementContext) {} + +// ExitSetTransactionStatement is called when production setTransactionStatement is exited. +func (s *BaseMySqlParserListener) ExitSetTransactionStatement(ctx *SetTransactionStatementContext) {} + +// EnterTransactionMode is called when production transactionMode is entered. +func (s *BaseMySqlParserListener) EnterTransactionMode(ctx *TransactionModeContext) {} + +// ExitTransactionMode is called when production transactionMode is exited. +func (s *BaseMySqlParserListener) ExitTransactionMode(ctx *TransactionModeContext) {} + +// EnterLockTableElement is called when production lockTableElement is entered. +func (s *BaseMySqlParserListener) EnterLockTableElement(ctx *LockTableElementContext) {} + +// ExitLockTableElement is called when production lockTableElement is exited. +func (s *BaseMySqlParserListener) ExitLockTableElement(ctx *LockTableElementContext) {} + +// EnterLockAction is called when production lockAction is entered. +func (s *BaseMySqlParserListener) EnterLockAction(ctx *LockActionContext) {} + +// ExitLockAction is called when production lockAction is exited. +func (s *BaseMySqlParserListener) ExitLockAction(ctx *LockActionContext) {} + +// EnterTransactionOption is called when production transactionOption is entered. +func (s *BaseMySqlParserListener) EnterTransactionOption(ctx *TransactionOptionContext) {} + +// ExitTransactionOption is called when production transactionOption is exited. +func (s *BaseMySqlParserListener) ExitTransactionOption(ctx *TransactionOptionContext) {} + +// EnterTransactionLevel is called when production transactionLevel is entered. +func (s *BaseMySqlParserListener) EnterTransactionLevel(ctx *TransactionLevelContext) {} + +// ExitTransactionLevel is called when production transactionLevel is exited. +func (s *BaseMySqlParserListener) ExitTransactionLevel(ctx *TransactionLevelContext) {} + +// EnterChangeMaster is called when production changeMaster is entered. +func (s *BaseMySqlParserListener) EnterChangeMaster(ctx *ChangeMasterContext) {} + +// ExitChangeMaster is called when production changeMaster is exited. +func (s *BaseMySqlParserListener) ExitChangeMaster(ctx *ChangeMasterContext) {} + +// EnterChangeReplicationFilter is called when production changeReplicationFilter is entered. +func (s *BaseMySqlParserListener) EnterChangeReplicationFilter(ctx *ChangeReplicationFilterContext) {} + +// ExitChangeReplicationFilter is called when production changeReplicationFilter is exited. +func (s *BaseMySqlParserListener) ExitChangeReplicationFilter(ctx *ChangeReplicationFilterContext) {} + +// EnterPurgeBinaryLogs is called when production purgeBinaryLogs is entered. +func (s *BaseMySqlParserListener) EnterPurgeBinaryLogs(ctx *PurgeBinaryLogsContext) {} + +// ExitPurgeBinaryLogs is called when production purgeBinaryLogs is exited. +func (s *BaseMySqlParserListener) ExitPurgeBinaryLogs(ctx *PurgeBinaryLogsContext) {} + +// EnterResetMaster is called when production resetMaster is entered. +func (s *BaseMySqlParserListener) EnterResetMaster(ctx *ResetMasterContext) {} + +// ExitResetMaster is called when production resetMaster is exited. +func (s *BaseMySqlParserListener) ExitResetMaster(ctx *ResetMasterContext) {} + +// EnterResetSlave is called when production resetSlave is entered. +func (s *BaseMySqlParserListener) EnterResetSlave(ctx *ResetSlaveContext) {} + +// ExitResetSlave is called when production resetSlave is exited. +func (s *BaseMySqlParserListener) ExitResetSlave(ctx *ResetSlaveContext) {} + +// EnterStartSlave is called when production startSlave is entered. +func (s *BaseMySqlParserListener) EnterStartSlave(ctx *StartSlaveContext) {} + +// ExitStartSlave is called when production startSlave is exited. +func (s *BaseMySqlParserListener) ExitStartSlave(ctx *StartSlaveContext) {} + +// EnterStopSlave is called when production stopSlave is entered. +func (s *BaseMySqlParserListener) EnterStopSlave(ctx *StopSlaveContext) {} + +// ExitStopSlave is called when production stopSlave is exited. +func (s *BaseMySqlParserListener) ExitStopSlave(ctx *StopSlaveContext) {} + +// EnterStartGroupReplication is called when production startGroupReplication is entered. +func (s *BaseMySqlParserListener) EnterStartGroupReplication(ctx *StartGroupReplicationContext) {} + +// ExitStartGroupReplication is called when production startGroupReplication is exited. +func (s *BaseMySqlParserListener) ExitStartGroupReplication(ctx *StartGroupReplicationContext) {} + +// EnterStopGroupReplication is called when production stopGroupReplication is entered. +func (s *BaseMySqlParserListener) EnterStopGroupReplication(ctx *StopGroupReplicationContext) {} + +// ExitStopGroupReplication is called when production stopGroupReplication is exited. +func (s *BaseMySqlParserListener) ExitStopGroupReplication(ctx *StopGroupReplicationContext) {} + +// EnterMasterStringOption is called when production masterStringOption is entered. +func (s *BaseMySqlParserListener) EnterMasterStringOption(ctx *MasterStringOptionContext) {} + +// ExitMasterStringOption is called when production masterStringOption is exited. +func (s *BaseMySqlParserListener) ExitMasterStringOption(ctx *MasterStringOptionContext) {} + +// EnterMasterDecimalOption is called when production masterDecimalOption is entered. +func (s *BaseMySqlParserListener) EnterMasterDecimalOption(ctx *MasterDecimalOptionContext) {} + +// ExitMasterDecimalOption is called when production masterDecimalOption is exited. +func (s *BaseMySqlParserListener) ExitMasterDecimalOption(ctx *MasterDecimalOptionContext) {} + +// EnterMasterBoolOption is called when production masterBoolOption is entered. +func (s *BaseMySqlParserListener) EnterMasterBoolOption(ctx *MasterBoolOptionContext) {} + +// ExitMasterBoolOption is called when production masterBoolOption is exited. +func (s *BaseMySqlParserListener) ExitMasterBoolOption(ctx *MasterBoolOptionContext) {} + +// EnterMasterRealOption is called when production masterRealOption is entered. +func (s *BaseMySqlParserListener) EnterMasterRealOption(ctx *MasterRealOptionContext) {} + +// ExitMasterRealOption is called when production masterRealOption is exited. +func (s *BaseMySqlParserListener) ExitMasterRealOption(ctx *MasterRealOptionContext) {} + +// EnterMasterUidListOption is called when production masterUidListOption is entered. +func (s *BaseMySqlParserListener) EnterMasterUidListOption(ctx *MasterUidListOptionContext) {} + +// ExitMasterUidListOption is called when production masterUidListOption is exited. +func (s *BaseMySqlParserListener) ExitMasterUidListOption(ctx *MasterUidListOptionContext) {} + +// EnterStringMasterOption is called when production stringMasterOption is entered. +func (s *BaseMySqlParserListener) EnterStringMasterOption(ctx *StringMasterOptionContext) {} + +// ExitStringMasterOption is called when production stringMasterOption is exited. +func (s *BaseMySqlParserListener) ExitStringMasterOption(ctx *StringMasterOptionContext) {} + +// EnterDecimalMasterOption is called when production decimalMasterOption is entered. +func (s *BaseMySqlParserListener) EnterDecimalMasterOption(ctx *DecimalMasterOptionContext) {} + +// ExitDecimalMasterOption is called when production decimalMasterOption is exited. +func (s *BaseMySqlParserListener) ExitDecimalMasterOption(ctx *DecimalMasterOptionContext) {} + +// EnterBoolMasterOption is called when production boolMasterOption is entered. +func (s *BaseMySqlParserListener) EnterBoolMasterOption(ctx *BoolMasterOptionContext) {} + +// ExitBoolMasterOption is called when production boolMasterOption is exited. +func (s *BaseMySqlParserListener) ExitBoolMasterOption(ctx *BoolMasterOptionContext) {} + +// EnterChannelOption is called when production channelOption is entered. +func (s *BaseMySqlParserListener) EnterChannelOption(ctx *ChannelOptionContext) {} + +// ExitChannelOption is called when production channelOption is exited. +func (s *BaseMySqlParserListener) ExitChannelOption(ctx *ChannelOptionContext) {} + +// EnterDoDbReplication is called when production doDbReplication is entered. +func (s *BaseMySqlParserListener) EnterDoDbReplication(ctx *DoDbReplicationContext) {} + +// ExitDoDbReplication is called when production doDbReplication is exited. +func (s *BaseMySqlParserListener) ExitDoDbReplication(ctx *DoDbReplicationContext) {} + +// EnterIgnoreDbReplication is called when production ignoreDbReplication is entered. +func (s *BaseMySqlParserListener) EnterIgnoreDbReplication(ctx *IgnoreDbReplicationContext) {} + +// ExitIgnoreDbReplication is called when production ignoreDbReplication is exited. +func (s *BaseMySqlParserListener) ExitIgnoreDbReplication(ctx *IgnoreDbReplicationContext) {} + +// EnterDoTableReplication is called when production doTableReplication is entered. +func (s *BaseMySqlParserListener) EnterDoTableReplication(ctx *DoTableReplicationContext) {} + +// ExitDoTableReplication is called when production doTableReplication is exited. +func (s *BaseMySqlParserListener) ExitDoTableReplication(ctx *DoTableReplicationContext) {} + +// EnterIgnoreTableReplication is called when production ignoreTableReplication is entered. +func (s *BaseMySqlParserListener) EnterIgnoreTableReplication(ctx *IgnoreTableReplicationContext) {} + +// ExitIgnoreTableReplication is called when production ignoreTableReplication is exited. +func (s *BaseMySqlParserListener) ExitIgnoreTableReplication(ctx *IgnoreTableReplicationContext) {} + +// EnterWildDoTableReplication is called when production wildDoTableReplication is entered. +func (s *BaseMySqlParserListener) EnterWildDoTableReplication(ctx *WildDoTableReplicationContext) {} + +// ExitWildDoTableReplication is called when production wildDoTableReplication is exited. +func (s *BaseMySqlParserListener) ExitWildDoTableReplication(ctx *WildDoTableReplicationContext) {} + +// EnterWildIgnoreTableReplication is called when production wildIgnoreTableReplication is entered. +func (s *BaseMySqlParserListener) EnterWildIgnoreTableReplication(ctx *WildIgnoreTableReplicationContext) { +} + +// ExitWildIgnoreTableReplication is called when production wildIgnoreTableReplication is exited. +func (s *BaseMySqlParserListener) ExitWildIgnoreTableReplication(ctx *WildIgnoreTableReplicationContext) { +} + +// EnterRewriteDbReplication is called when production rewriteDbReplication is entered. +func (s *BaseMySqlParserListener) EnterRewriteDbReplication(ctx *RewriteDbReplicationContext) {} + +// ExitRewriteDbReplication is called when production rewriteDbReplication is exited. +func (s *BaseMySqlParserListener) ExitRewriteDbReplication(ctx *RewriteDbReplicationContext) {} + +// EnterTablePair is called when production tablePair is entered. +func (s *BaseMySqlParserListener) EnterTablePair(ctx *TablePairContext) {} + +// ExitTablePair is called when production tablePair is exited. +func (s *BaseMySqlParserListener) ExitTablePair(ctx *TablePairContext) {} + +// EnterThreadType is called when production threadType is entered. +func (s *BaseMySqlParserListener) EnterThreadType(ctx *ThreadTypeContext) {} + +// ExitThreadType is called when production threadType is exited. +func (s *BaseMySqlParserListener) ExitThreadType(ctx *ThreadTypeContext) {} + +// EnterGtidsUntilOption is called when production gtidsUntilOption is entered. +func (s *BaseMySqlParserListener) EnterGtidsUntilOption(ctx *GtidsUntilOptionContext) {} + +// ExitGtidsUntilOption is called when production gtidsUntilOption is exited. +func (s *BaseMySqlParserListener) ExitGtidsUntilOption(ctx *GtidsUntilOptionContext) {} + +// EnterMasterLogUntilOption is called when production masterLogUntilOption is entered. +func (s *BaseMySqlParserListener) EnterMasterLogUntilOption(ctx *MasterLogUntilOptionContext) {} + +// ExitMasterLogUntilOption is called when production masterLogUntilOption is exited. +func (s *BaseMySqlParserListener) ExitMasterLogUntilOption(ctx *MasterLogUntilOptionContext) {} + +// EnterRelayLogUntilOption is called when production relayLogUntilOption is entered. +func (s *BaseMySqlParserListener) EnterRelayLogUntilOption(ctx *RelayLogUntilOptionContext) {} + +// ExitRelayLogUntilOption is called when production relayLogUntilOption is exited. +func (s *BaseMySqlParserListener) ExitRelayLogUntilOption(ctx *RelayLogUntilOptionContext) {} + +// EnterSqlGapsUntilOption is called when production sqlGapsUntilOption is entered. +func (s *BaseMySqlParserListener) EnterSqlGapsUntilOption(ctx *SqlGapsUntilOptionContext) {} + +// ExitSqlGapsUntilOption is called when production sqlGapsUntilOption is exited. +func (s *BaseMySqlParserListener) ExitSqlGapsUntilOption(ctx *SqlGapsUntilOptionContext) {} + +// EnterUserConnectionOption is called when production userConnectionOption is entered. +func (s *BaseMySqlParserListener) EnterUserConnectionOption(ctx *UserConnectionOptionContext) {} + +// ExitUserConnectionOption is called when production userConnectionOption is exited. +func (s *BaseMySqlParserListener) ExitUserConnectionOption(ctx *UserConnectionOptionContext) {} + +// EnterPasswordConnectionOption is called when production passwordConnectionOption is entered. +func (s *BaseMySqlParserListener) EnterPasswordConnectionOption(ctx *PasswordConnectionOptionContext) { +} + +// ExitPasswordConnectionOption is called when production passwordConnectionOption is exited. +func (s *BaseMySqlParserListener) ExitPasswordConnectionOption(ctx *PasswordConnectionOptionContext) { +} + +// EnterDefaultAuthConnectionOption is called when production defaultAuthConnectionOption is entered. +func (s *BaseMySqlParserListener) EnterDefaultAuthConnectionOption(ctx *DefaultAuthConnectionOptionContext) { +} + +// ExitDefaultAuthConnectionOption is called when production defaultAuthConnectionOption is exited. +func (s *BaseMySqlParserListener) ExitDefaultAuthConnectionOption(ctx *DefaultAuthConnectionOptionContext) { +} + +// EnterPluginDirConnectionOption is called when production pluginDirConnectionOption is entered. +func (s *BaseMySqlParserListener) EnterPluginDirConnectionOption(ctx *PluginDirConnectionOptionContext) { +} + +// ExitPluginDirConnectionOption is called when production pluginDirConnectionOption is exited. +func (s *BaseMySqlParserListener) ExitPluginDirConnectionOption(ctx *PluginDirConnectionOptionContext) { +} + +// EnterGtuidSet is called when production gtuidSet is entered. +func (s *BaseMySqlParserListener) EnterGtuidSet(ctx *GtuidSetContext) {} + +// ExitGtuidSet is called when production gtuidSet is exited. +func (s *BaseMySqlParserListener) ExitGtuidSet(ctx *GtuidSetContext) {} + +// EnterXaStartTransaction is called when production xaStartTransaction is entered. +func (s *BaseMySqlParserListener) EnterXaStartTransaction(ctx *XaStartTransactionContext) {} + +// ExitXaStartTransaction is called when production xaStartTransaction is exited. +func (s *BaseMySqlParserListener) ExitXaStartTransaction(ctx *XaStartTransactionContext) {} + +// EnterXaEndTransaction is called when production xaEndTransaction is entered. +func (s *BaseMySqlParserListener) EnterXaEndTransaction(ctx *XaEndTransactionContext) {} + +// ExitXaEndTransaction is called when production xaEndTransaction is exited. +func (s *BaseMySqlParserListener) ExitXaEndTransaction(ctx *XaEndTransactionContext) {} + +// EnterXaPrepareStatement is called when production xaPrepareStatement is entered. +func (s *BaseMySqlParserListener) EnterXaPrepareStatement(ctx *XaPrepareStatementContext) {} + +// ExitXaPrepareStatement is called when production xaPrepareStatement is exited. +func (s *BaseMySqlParserListener) ExitXaPrepareStatement(ctx *XaPrepareStatementContext) {} + +// EnterXaCommitWork is called when production xaCommitWork is entered. +func (s *BaseMySqlParserListener) EnterXaCommitWork(ctx *XaCommitWorkContext) {} + +// ExitXaCommitWork is called when production xaCommitWork is exited. +func (s *BaseMySqlParserListener) ExitXaCommitWork(ctx *XaCommitWorkContext) {} + +// EnterXaRollbackWork is called when production xaRollbackWork is entered. +func (s *BaseMySqlParserListener) EnterXaRollbackWork(ctx *XaRollbackWorkContext) {} + +// ExitXaRollbackWork is called when production xaRollbackWork is exited. +func (s *BaseMySqlParserListener) ExitXaRollbackWork(ctx *XaRollbackWorkContext) {} + +// EnterXaRecoverWork is called when production xaRecoverWork is entered. +func (s *BaseMySqlParserListener) EnterXaRecoverWork(ctx *XaRecoverWorkContext) {} + +// ExitXaRecoverWork is called when production xaRecoverWork is exited. +func (s *BaseMySqlParserListener) ExitXaRecoverWork(ctx *XaRecoverWorkContext) {} + +// EnterPrepareStatement is called when production prepareStatement is entered. +func (s *BaseMySqlParserListener) EnterPrepareStatement(ctx *PrepareStatementContext) {} + +// ExitPrepareStatement is called when production prepareStatement is exited. +func (s *BaseMySqlParserListener) ExitPrepareStatement(ctx *PrepareStatementContext) {} + +// EnterExecuteStatement is called when production executeStatement is entered. +func (s *BaseMySqlParserListener) EnterExecuteStatement(ctx *ExecuteStatementContext) {} + +// ExitExecuteStatement is called when production executeStatement is exited. +func (s *BaseMySqlParserListener) ExitExecuteStatement(ctx *ExecuteStatementContext) {} + +// EnterDeallocatePrepare is called when production deallocatePrepare is entered. +func (s *BaseMySqlParserListener) EnterDeallocatePrepare(ctx *DeallocatePrepareContext) {} + +// ExitDeallocatePrepare is called when production deallocatePrepare is exited. +func (s *BaseMySqlParserListener) ExitDeallocatePrepare(ctx *DeallocatePrepareContext) {} + +// EnterRoutineBody is called when production routineBody is entered. +func (s *BaseMySqlParserListener) EnterRoutineBody(ctx *RoutineBodyContext) {} + +// ExitRoutineBody is called when production routineBody is exited. +func (s *BaseMySqlParserListener) ExitRoutineBody(ctx *RoutineBodyContext) {} + +// EnterBlockStatement is called when production blockStatement is entered. +func (s *BaseMySqlParserListener) EnterBlockStatement(ctx *BlockStatementContext) {} + +// ExitBlockStatement is called when production blockStatement is exited. +func (s *BaseMySqlParserListener) ExitBlockStatement(ctx *BlockStatementContext) {} + +// EnterCaseStatement is called when production caseStatement is entered. +func (s *BaseMySqlParserListener) EnterCaseStatement(ctx *CaseStatementContext) {} + +// ExitCaseStatement is called when production caseStatement is exited. +func (s *BaseMySqlParserListener) ExitCaseStatement(ctx *CaseStatementContext) {} + +// EnterIfStatement is called when production ifStatement is entered. +func (s *BaseMySqlParserListener) EnterIfStatement(ctx *IfStatementContext) {} + +// ExitIfStatement is called when production ifStatement is exited. +func (s *BaseMySqlParserListener) ExitIfStatement(ctx *IfStatementContext) {} + +// EnterIterateStatement is called when production iterateStatement is entered. +func (s *BaseMySqlParserListener) EnterIterateStatement(ctx *IterateStatementContext) {} + +// ExitIterateStatement is called when production iterateStatement is exited. +func (s *BaseMySqlParserListener) ExitIterateStatement(ctx *IterateStatementContext) {} + +// EnterLeaveStatement is called when production leaveStatement is entered. +func (s *BaseMySqlParserListener) EnterLeaveStatement(ctx *LeaveStatementContext) {} + +// ExitLeaveStatement is called when production leaveStatement is exited. +func (s *BaseMySqlParserListener) ExitLeaveStatement(ctx *LeaveStatementContext) {} + +// EnterLoopStatement is called when production loopStatement is entered. +func (s *BaseMySqlParserListener) EnterLoopStatement(ctx *LoopStatementContext) {} + +// ExitLoopStatement is called when production loopStatement is exited. +func (s *BaseMySqlParserListener) ExitLoopStatement(ctx *LoopStatementContext) {} + +// EnterRepeatStatement is called when production repeatStatement is entered. +func (s *BaseMySqlParserListener) EnterRepeatStatement(ctx *RepeatStatementContext) {} + +// ExitRepeatStatement is called when production repeatStatement is exited. +func (s *BaseMySqlParserListener) ExitRepeatStatement(ctx *RepeatStatementContext) {} + +// EnterReturnStatement is called when production returnStatement is entered. +func (s *BaseMySqlParserListener) EnterReturnStatement(ctx *ReturnStatementContext) {} + +// ExitReturnStatement is called when production returnStatement is exited. +func (s *BaseMySqlParserListener) ExitReturnStatement(ctx *ReturnStatementContext) {} + +// EnterWhileStatement is called when production whileStatement is entered. +func (s *BaseMySqlParserListener) EnterWhileStatement(ctx *WhileStatementContext) {} + +// ExitWhileStatement is called when production whileStatement is exited. +func (s *BaseMySqlParserListener) ExitWhileStatement(ctx *WhileStatementContext) {} + +// EnterCloseCursor is called when production CloseCursor is entered. +func (s *BaseMySqlParserListener) EnterCloseCursor(ctx *CloseCursorContext) {} + +// ExitCloseCursor is called when production CloseCursor is exited. +func (s *BaseMySqlParserListener) ExitCloseCursor(ctx *CloseCursorContext) {} + +// EnterFetchCursor is called when production FetchCursor is entered. +func (s *BaseMySqlParserListener) EnterFetchCursor(ctx *FetchCursorContext) {} + +// ExitFetchCursor is called when production FetchCursor is exited. +func (s *BaseMySqlParserListener) ExitFetchCursor(ctx *FetchCursorContext) {} + +// EnterOpenCursor is called when production OpenCursor is entered. +func (s *BaseMySqlParserListener) EnterOpenCursor(ctx *OpenCursorContext) {} + +// ExitOpenCursor is called when production OpenCursor is exited. +func (s *BaseMySqlParserListener) ExitOpenCursor(ctx *OpenCursorContext) {} + +// EnterDeclareVariable is called when production declareVariable is entered. +func (s *BaseMySqlParserListener) EnterDeclareVariable(ctx *DeclareVariableContext) {} + +// ExitDeclareVariable is called when production declareVariable is exited. +func (s *BaseMySqlParserListener) ExitDeclareVariable(ctx *DeclareVariableContext) {} + +// EnterDeclareCondition is called when production declareCondition is entered. +func (s *BaseMySqlParserListener) EnterDeclareCondition(ctx *DeclareConditionContext) {} + +// ExitDeclareCondition is called when production declareCondition is exited. +func (s *BaseMySqlParserListener) ExitDeclareCondition(ctx *DeclareConditionContext) {} + +// EnterDeclareCursor is called when production declareCursor is entered. +func (s *BaseMySqlParserListener) EnterDeclareCursor(ctx *DeclareCursorContext) {} + +// ExitDeclareCursor is called when production declareCursor is exited. +func (s *BaseMySqlParserListener) ExitDeclareCursor(ctx *DeclareCursorContext) {} + +// EnterDeclareHandler is called when production declareHandler is entered. +func (s *BaseMySqlParserListener) EnterDeclareHandler(ctx *DeclareHandlerContext) {} + +// ExitDeclareHandler is called when production declareHandler is exited. +func (s *BaseMySqlParserListener) ExitDeclareHandler(ctx *DeclareHandlerContext) {} + +// EnterHandlerConditionCode is called when production handlerConditionCode is entered. +func (s *BaseMySqlParserListener) EnterHandlerConditionCode(ctx *HandlerConditionCodeContext) {} + +// ExitHandlerConditionCode is called when production handlerConditionCode is exited. +func (s *BaseMySqlParserListener) ExitHandlerConditionCode(ctx *HandlerConditionCodeContext) {} + +// EnterHandlerConditionState is called when production handlerConditionState is entered. +func (s *BaseMySqlParserListener) EnterHandlerConditionState(ctx *HandlerConditionStateContext) {} + +// ExitHandlerConditionState is called when production handlerConditionState is exited. +func (s *BaseMySqlParserListener) ExitHandlerConditionState(ctx *HandlerConditionStateContext) {} + +// EnterHandlerConditionName is called when production handlerConditionName is entered. +func (s *BaseMySqlParserListener) EnterHandlerConditionName(ctx *HandlerConditionNameContext) {} + +// ExitHandlerConditionName is called when production handlerConditionName is exited. +func (s *BaseMySqlParserListener) ExitHandlerConditionName(ctx *HandlerConditionNameContext) {} + +// EnterHandlerConditionWarning is called when production handlerConditionWarning is entered. +func (s *BaseMySqlParserListener) EnterHandlerConditionWarning(ctx *HandlerConditionWarningContext) {} + +// ExitHandlerConditionWarning is called when production handlerConditionWarning is exited. +func (s *BaseMySqlParserListener) ExitHandlerConditionWarning(ctx *HandlerConditionWarningContext) {} + +// EnterHandlerConditionNotfound is called when production handlerConditionNotfound is entered. +func (s *BaseMySqlParserListener) EnterHandlerConditionNotfound(ctx *HandlerConditionNotfoundContext) { +} + +// ExitHandlerConditionNotfound is called when production handlerConditionNotfound is exited. +func (s *BaseMySqlParserListener) ExitHandlerConditionNotfound(ctx *HandlerConditionNotfoundContext) { +} + +// EnterHandlerConditionException is called when production handlerConditionException is entered. +func (s *BaseMySqlParserListener) EnterHandlerConditionException(ctx *HandlerConditionExceptionContext) { +} + +// ExitHandlerConditionException is called when production handlerConditionException is exited. +func (s *BaseMySqlParserListener) ExitHandlerConditionException(ctx *HandlerConditionExceptionContext) { +} + +// EnterProcedureSqlStatement is called when production procedureSqlStatement is entered. +func (s *BaseMySqlParserListener) EnterProcedureSqlStatement(ctx *ProcedureSqlStatementContext) {} + +// ExitProcedureSqlStatement is called when production procedureSqlStatement is exited. +func (s *BaseMySqlParserListener) ExitProcedureSqlStatement(ctx *ProcedureSqlStatementContext) {} + +// EnterCaseAlternative is called when production caseAlternative is entered. +func (s *BaseMySqlParserListener) EnterCaseAlternative(ctx *CaseAlternativeContext) {} + +// ExitCaseAlternative is called when production caseAlternative is exited. +func (s *BaseMySqlParserListener) ExitCaseAlternative(ctx *CaseAlternativeContext) {} + +// EnterElifAlternative is called when production elifAlternative is entered. +func (s *BaseMySqlParserListener) EnterElifAlternative(ctx *ElifAlternativeContext) {} + +// ExitElifAlternative is called when production elifAlternative is exited. +func (s *BaseMySqlParserListener) ExitElifAlternative(ctx *ElifAlternativeContext) {} + +// EnterAlterUserMysqlV56 is called when production alterUserMysqlV56 is entered. +func (s *BaseMySqlParserListener) EnterAlterUserMysqlV56(ctx *AlterUserMysqlV56Context) {} + +// ExitAlterUserMysqlV56 is called when production alterUserMysqlV56 is exited. +func (s *BaseMySqlParserListener) ExitAlterUserMysqlV56(ctx *AlterUserMysqlV56Context) {} + +// EnterAlterUserMysqlV80 is called when production alterUserMysqlV80 is entered. +func (s *BaseMySqlParserListener) EnterAlterUserMysqlV80(ctx *AlterUserMysqlV80Context) {} + +// ExitAlterUserMysqlV80 is called when production alterUserMysqlV80 is exited. +func (s *BaseMySqlParserListener) ExitAlterUserMysqlV80(ctx *AlterUserMysqlV80Context) {} + +// EnterCreateUserMysqlV56 is called when production createUserMysqlV56 is entered. +func (s *BaseMySqlParserListener) EnterCreateUserMysqlV56(ctx *CreateUserMysqlV56Context) {} + +// ExitCreateUserMysqlV56 is called when production createUserMysqlV56 is exited. +func (s *BaseMySqlParserListener) ExitCreateUserMysqlV56(ctx *CreateUserMysqlV56Context) {} + +// EnterCreateUserMysqlV80 is called when production createUserMysqlV80 is entered. +func (s *BaseMySqlParserListener) EnterCreateUserMysqlV80(ctx *CreateUserMysqlV80Context) {} + +// ExitCreateUserMysqlV80 is called when production createUserMysqlV80 is exited. +func (s *BaseMySqlParserListener) ExitCreateUserMysqlV80(ctx *CreateUserMysqlV80Context) {} + +// EnterDropUser is called when production dropUser is entered. +func (s *BaseMySqlParserListener) EnterDropUser(ctx *DropUserContext) {} + +// ExitDropUser is called when production dropUser is exited. +func (s *BaseMySqlParserListener) ExitDropUser(ctx *DropUserContext) {} + +// EnterGrantStatement is called when production grantStatement is entered. +func (s *BaseMySqlParserListener) EnterGrantStatement(ctx *GrantStatementContext) {} + +// ExitGrantStatement is called when production grantStatement is exited. +func (s *BaseMySqlParserListener) ExitGrantStatement(ctx *GrantStatementContext) {} + +// EnterRoleOption is called when production roleOption is entered. +func (s *BaseMySqlParserListener) EnterRoleOption(ctx *RoleOptionContext) {} + +// ExitRoleOption is called when production roleOption is exited. +func (s *BaseMySqlParserListener) ExitRoleOption(ctx *RoleOptionContext) {} + +// EnterGrantProxy is called when production grantProxy is entered. +func (s *BaseMySqlParserListener) EnterGrantProxy(ctx *GrantProxyContext) {} + +// ExitGrantProxy is called when production grantProxy is exited. +func (s *BaseMySqlParserListener) ExitGrantProxy(ctx *GrantProxyContext) {} + +// EnterRenameUser is called when production renameUser is entered. +func (s *BaseMySqlParserListener) EnterRenameUser(ctx *RenameUserContext) {} + +// ExitRenameUser is called when production renameUser is exited. +func (s *BaseMySqlParserListener) ExitRenameUser(ctx *RenameUserContext) {} + +// EnterDetailRevoke is called when production detailRevoke is entered. +func (s *BaseMySqlParserListener) EnterDetailRevoke(ctx *DetailRevokeContext) {} + +// ExitDetailRevoke is called when production detailRevoke is exited. +func (s *BaseMySqlParserListener) ExitDetailRevoke(ctx *DetailRevokeContext) {} + +// EnterShortRevoke is called when production shortRevoke is entered. +func (s *BaseMySqlParserListener) EnterShortRevoke(ctx *ShortRevokeContext) {} + +// ExitShortRevoke is called when production shortRevoke is exited. +func (s *BaseMySqlParserListener) ExitShortRevoke(ctx *ShortRevokeContext) {} + +// EnterRoleRevoke is called when production roleRevoke is entered. +func (s *BaseMySqlParserListener) EnterRoleRevoke(ctx *RoleRevokeContext) {} + +// ExitRoleRevoke is called when production roleRevoke is exited. +func (s *BaseMySqlParserListener) ExitRoleRevoke(ctx *RoleRevokeContext) {} + +// EnterRevokeProxy is called when production revokeProxy is entered. +func (s *BaseMySqlParserListener) EnterRevokeProxy(ctx *RevokeProxyContext) {} + +// ExitRevokeProxy is called when production revokeProxy is exited. +func (s *BaseMySqlParserListener) ExitRevokeProxy(ctx *RevokeProxyContext) {} + +// EnterSetPasswordStatement is called when production setPasswordStatement is entered. +func (s *BaseMySqlParserListener) EnterSetPasswordStatement(ctx *SetPasswordStatementContext) {} + +// ExitSetPasswordStatement is called when production setPasswordStatement is exited. +func (s *BaseMySqlParserListener) ExitSetPasswordStatement(ctx *SetPasswordStatementContext) {} + +// EnterUserSpecification is called when production userSpecification is entered. +func (s *BaseMySqlParserListener) EnterUserSpecification(ctx *UserSpecificationContext) {} + +// ExitUserSpecification is called when production userSpecification is exited. +func (s *BaseMySqlParserListener) ExitUserSpecification(ctx *UserSpecificationContext) {} + +// EnterHashAuthOption is called when production hashAuthOption is entered. +func (s *BaseMySqlParserListener) EnterHashAuthOption(ctx *HashAuthOptionContext) {} + +// ExitHashAuthOption is called when production hashAuthOption is exited. +func (s *BaseMySqlParserListener) ExitHashAuthOption(ctx *HashAuthOptionContext) {} + +// EnterRandomAuthOption is called when production randomAuthOption is entered. +func (s *BaseMySqlParserListener) EnterRandomAuthOption(ctx *RandomAuthOptionContext) {} + +// ExitRandomAuthOption is called when production randomAuthOption is exited. +func (s *BaseMySqlParserListener) ExitRandomAuthOption(ctx *RandomAuthOptionContext) {} + +// EnterStringAuthOption is called when production stringAuthOption is entered. +func (s *BaseMySqlParserListener) EnterStringAuthOption(ctx *StringAuthOptionContext) {} + +// ExitStringAuthOption is called when production stringAuthOption is exited. +func (s *BaseMySqlParserListener) ExitStringAuthOption(ctx *StringAuthOptionContext) {} + +// EnterModuleAuthOption is called when production moduleAuthOption is entered. +func (s *BaseMySqlParserListener) EnterModuleAuthOption(ctx *ModuleAuthOptionContext) {} + +// ExitModuleAuthOption is called when production moduleAuthOption is exited. +func (s *BaseMySqlParserListener) ExitModuleAuthOption(ctx *ModuleAuthOptionContext) {} + +// EnterSimpleAuthOption is called when production simpleAuthOption is entered. +func (s *BaseMySqlParserListener) EnterSimpleAuthOption(ctx *SimpleAuthOptionContext) {} + +// ExitSimpleAuthOption is called when production simpleAuthOption is exited. +func (s *BaseMySqlParserListener) ExitSimpleAuthOption(ctx *SimpleAuthOptionContext) {} + +// EnterAuthOptionClause is called when production authOptionClause is entered. +func (s *BaseMySqlParserListener) EnterAuthOptionClause(ctx *AuthOptionClauseContext) {} + +// ExitAuthOptionClause is called when production authOptionClause is exited. +func (s *BaseMySqlParserListener) ExitAuthOptionClause(ctx *AuthOptionClauseContext) {} + +// EnterModule is called when production module is entered. +func (s *BaseMySqlParserListener) EnterModule(ctx *ModuleContext) {} + +// ExitModule is called when production module is exited. +func (s *BaseMySqlParserListener) ExitModule(ctx *ModuleContext) {} + +// EnterPasswordModuleOption is called when production passwordModuleOption is entered. +func (s *BaseMySqlParserListener) EnterPasswordModuleOption(ctx *PasswordModuleOptionContext) {} + +// ExitPasswordModuleOption is called when production passwordModuleOption is exited. +func (s *BaseMySqlParserListener) ExitPasswordModuleOption(ctx *PasswordModuleOptionContext) {} + +// EnterTlsOption is called when production tlsOption is entered. +func (s *BaseMySqlParserListener) EnterTlsOption(ctx *TlsOptionContext) {} + +// ExitTlsOption is called when production tlsOption is exited. +func (s *BaseMySqlParserListener) ExitTlsOption(ctx *TlsOptionContext) {} + +// EnterUserResourceOption is called when production userResourceOption is entered. +func (s *BaseMySqlParserListener) EnterUserResourceOption(ctx *UserResourceOptionContext) {} + +// ExitUserResourceOption is called when production userResourceOption is exited. +func (s *BaseMySqlParserListener) ExitUserResourceOption(ctx *UserResourceOptionContext) {} + +// EnterUserPasswordOption is called when production userPasswordOption is entered. +func (s *BaseMySqlParserListener) EnterUserPasswordOption(ctx *UserPasswordOptionContext) {} + +// ExitUserPasswordOption is called when production userPasswordOption is exited. +func (s *BaseMySqlParserListener) ExitUserPasswordOption(ctx *UserPasswordOptionContext) {} + +// EnterUserLockOption is called when production userLockOption is entered. +func (s *BaseMySqlParserListener) EnterUserLockOption(ctx *UserLockOptionContext) {} + +// ExitUserLockOption is called when production userLockOption is exited. +func (s *BaseMySqlParserListener) ExitUserLockOption(ctx *UserLockOptionContext) {} + +// EnterPrivelegeClause is called when production privelegeClause is entered. +func (s *BaseMySqlParserListener) EnterPrivelegeClause(ctx *PrivelegeClauseContext) {} + +// ExitPrivelegeClause is called when production privelegeClause is exited. +func (s *BaseMySqlParserListener) ExitPrivelegeClause(ctx *PrivelegeClauseContext) {} + +// EnterPrivilege is called when production privilege is entered. +func (s *BaseMySqlParserListener) EnterPrivilege(ctx *PrivilegeContext) {} + +// ExitPrivilege is called when production privilege is exited. +func (s *BaseMySqlParserListener) ExitPrivilege(ctx *PrivilegeContext) {} + +// EnterCurrentSchemaPriviLevel is called when production currentSchemaPriviLevel is entered. +func (s *BaseMySqlParserListener) EnterCurrentSchemaPriviLevel(ctx *CurrentSchemaPriviLevelContext) {} + +// ExitCurrentSchemaPriviLevel is called when production currentSchemaPriviLevel is exited. +func (s *BaseMySqlParserListener) ExitCurrentSchemaPriviLevel(ctx *CurrentSchemaPriviLevelContext) {} + +// EnterGlobalPrivLevel is called when production globalPrivLevel is entered. +func (s *BaseMySqlParserListener) EnterGlobalPrivLevel(ctx *GlobalPrivLevelContext) {} + +// ExitGlobalPrivLevel is called when production globalPrivLevel is exited. +func (s *BaseMySqlParserListener) ExitGlobalPrivLevel(ctx *GlobalPrivLevelContext) {} + +// EnterDefiniteSchemaPrivLevel is called when production definiteSchemaPrivLevel is entered. +func (s *BaseMySqlParserListener) EnterDefiniteSchemaPrivLevel(ctx *DefiniteSchemaPrivLevelContext) {} + +// ExitDefiniteSchemaPrivLevel is called when production definiteSchemaPrivLevel is exited. +func (s *BaseMySqlParserListener) ExitDefiniteSchemaPrivLevel(ctx *DefiniteSchemaPrivLevelContext) {} + +// EnterDefiniteFullTablePrivLevel is called when production definiteFullTablePrivLevel is entered. +func (s *BaseMySqlParserListener) EnterDefiniteFullTablePrivLevel(ctx *DefiniteFullTablePrivLevelContext) { +} + +// ExitDefiniteFullTablePrivLevel is called when production definiteFullTablePrivLevel is exited. +func (s *BaseMySqlParserListener) ExitDefiniteFullTablePrivLevel(ctx *DefiniteFullTablePrivLevelContext) { +} + +// EnterDefiniteFullTablePrivLevel2 is called when production definiteFullTablePrivLevel2 is entered. +func (s *BaseMySqlParserListener) EnterDefiniteFullTablePrivLevel2(ctx *DefiniteFullTablePrivLevel2Context) { +} + +// ExitDefiniteFullTablePrivLevel2 is called when production definiteFullTablePrivLevel2 is exited. +func (s *BaseMySqlParserListener) ExitDefiniteFullTablePrivLevel2(ctx *DefiniteFullTablePrivLevel2Context) { +} + +// EnterDefiniteTablePrivLevel is called when production definiteTablePrivLevel is entered. +func (s *BaseMySqlParserListener) EnterDefiniteTablePrivLevel(ctx *DefiniteTablePrivLevelContext) {} + +// ExitDefiniteTablePrivLevel is called when production definiteTablePrivLevel is exited. +func (s *BaseMySqlParserListener) ExitDefiniteTablePrivLevel(ctx *DefiniteTablePrivLevelContext) {} + +// EnterRenameUserClause is called when production renameUserClause is entered. +func (s *BaseMySqlParserListener) EnterRenameUserClause(ctx *RenameUserClauseContext) {} + +// ExitRenameUserClause is called when production renameUserClause is exited. +func (s *BaseMySqlParserListener) ExitRenameUserClause(ctx *RenameUserClauseContext) {} + +// EnterAnalyzeTable is called when production analyzeTable is entered. +func (s *BaseMySqlParserListener) EnterAnalyzeTable(ctx *AnalyzeTableContext) {} + +// ExitAnalyzeTable is called when production analyzeTable is exited. +func (s *BaseMySqlParserListener) ExitAnalyzeTable(ctx *AnalyzeTableContext) {} + +// EnterCheckTable is called when production checkTable is entered. +func (s *BaseMySqlParserListener) EnterCheckTable(ctx *CheckTableContext) {} + +// ExitCheckTable is called when production checkTable is exited. +func (s *BaseMySqlParserListener) ExitCheckTable(ctx *CheckTableContext) {} + +// EnterChecksumTable is called when production checksumTable is entered. +func (s *BaseMySqlParserListener) EnterChecksumTable(ctx *ChecksumTableContext) {} + +// ExitChecksumTable is called when production checksumTable is exited. +func (s *BaseMySqlParserListener) ExitChecksumTable(ctx *ChecksumTableContext) {} + +// EnterOptimizeTable is called when production optimizeTable is entered. +func (s *BaseMySqlParserListener) EnterOptimizeTable(ctx *OptimizeTableContext) {} + +// ExitOptimizeTable is called when production optimizeTable is exited. +func (s *BaseMySqlParserListener) ExitOptimizeTable(ctx *OptimizeTableContext) {} + +// EnterRepairTable is called when production repairTable is entered. +func (s *BaseMySqlParserListener) EnterRepairTable(ctx *RepairTableContext) {} + +// ExitRepairTable is called when production repairTable is exited. +func (s *BaseMySqlParserListener) ExitRepairTable(ctx *RepairTableContext) {} + +// EnterCheckTableOption is called when production checkTableOption is entered. +func (s *BaseMySqlParserListener) EnterCheckTableOption(ctx *CheckTableOptionContext) {} + +// ExitCheckTableOption is called when production checkTableOption is exited. +func (s *BaseMySqlParserListener) ExitCheckTableOption(ctx *CheckTableOptionContext) {} + +// EnterCreateUdfunction is called when production createUdfunction is entered. +func (s *BaseMySqlParserListener) EnterCreateUdfunction(ctx *CreateUdfunctionContext) {} + +// ExitCreateUdfunction is called when production createUdfunction is exited. +func (s *BaseMySqlParserListener) ExitCreateUdfunction(ctx *CreateUdfunctionContext) {} + +// EnterInstallPlugin is called when production installPlugin is entered. +func (s *BaseMySqlParserListener) EnterInstallPlugin(ctx *InstallPluginContext) {} + +// ExitInstallPlugin is called when production installPlugin is exited. +func (s *BaseMySqlParserListener) ExitInstallPlugin(ctx *InstallPluginContext) {} + +// EnterUninstallPlugin is called when production uninstallPlugin is entered. +func (s *BaseMySqlParserListener) EnterUninstallPlugin(ctx *UninstallPluginContext) {} + +// ExitUninstallPlugin is called when production uninstallPlugin is exited. +func (s *BaseMySqlParserListener) ExitUninstallPlugin(ctx *UninstallPluginContext) {} + +// EnterSetVariable is called when production setVariable is entered. +func (s *BaseMySqlParserListener) EnterSetVariable(ctx *SetVariableContext) {} + +// ExitSetVariable is called when production setVariable is exited. +func (s *BaseMySqlParserListener) ExitSetVariable(ctx *SetVariableContext) {} + +// EnterSetCharset is called when production setCharset is entered. +func (s *BaseMySqlParserListener) EnterSetCharset(ctx *SetCharsetContext) {} + +// ExitSetCharset is called when production setCharset is exited. +func (s *BaseMySqlParserListener) ExitSetCharset(ctx *SetCharsetContext) {} + +// EnterSetNames is called when production setNames is entered. +func (s *BaseMySqlParserListener) EnterSetNames(ctx *SetNamesContext) {} + +// ExitSetNames is called when production setNames is exited. +func (s *BaseMySqlParserListener) ExitSetNames(ctx *SetNamesContext) {} + +// EnterSetPassword is called when production setPassword is entered. +func (s *BaseMySqlParserListener) EnterSetPassword(ctx *SetPasswordContext) {} + +// ExitSetPassword is called when production setPassword is exited. +func (s *BaseMySqlParserListener) ExitSetPassword(ctx *SetPasswordContext) {} + +// EnterSetTransaction is called when production setTransaction is entered. +func (s *BaseMySqlParserListener) EnterSetTransaction(ctx *SetTransactionContext) {} + +// ExitSetTransaction is called when production setTransaction is exited. +func (s *BaseMySqlParserListener) ExitSetTransaction(ctx *SetTransactionContext) {} + +// EnterSetAutocommit is called when production setAutocommit is entered. +func (s *BaseMySqlParserListener) EnterSetAutocommit(ctx *SetAutocommitContext) {} + +// ExitSetAutocommit is called when production setAutocommit is exited. +func (s *BaseMySqlParserListener) ExitSetAutocommit(ctx *SetAutocommitContext) {} + +// EnterSetNewValueInsideTrigger is called when production setNewValueInsideTrigger is entered. +func (s *BaseMySqlParserListener) EnterSetNewValueInsideTrigger(ctx *SetNewValueInsideTriggerContext) { +} + +// ExitSetNewValueInsideTrigger is called when production setNewValueInsideTrigger is exited. +func (s *BaseMySqlParserListener) ExitSetNewValueInsideTrigger(ctx *SetNewValueInsideTriggerContext) { +} + +// EnterShowMasterLogs is called when production showMasterLogs is entered. +func (s *BaseMySqlParserListener) EnterShowMasterLogs(ctx *ShowMasterLogsContext) {} + +// ExitShowMasterLogs is called when production showMasterLogs is exited. +func (s *BaseMySqlParserListener) ExitShowMasterLogs(ctx *ShowMasterLogsContext) {} + +// EnterShowLogEvents is called when production showLogEvents is entered. +func (s *BaseMySqlParserListener) EnterShowLogEvents(ctx *ShowLogEventsContext) {} + +// ExitShowLogEvents is called when production showLogEvents is exited. +func (s *BaseMySqlParserListener) ExitShowLogEvents(ctx *ShowLogEventsContext) {} + +// EnterShowObjectFilter is called when production showObjectFilter is entered. +func (s *BaseMySqlParserListener) EnterShowObjectFilter(ctx *ShowObjectFilterContext) {} + +// ExitShowObjectFilter is called when production showObjectFilter is exited. +func (s *BaseMySqlParserListener) ExitShowObjectFilter(ctx *ShowObjectFilterContext) {} + +// EnterShowColumns is called when production showColumns is entered. +func (s *BaseMySqlParserListener) EnterShowColumns(ctx *ShowColumnsContext) {} + +// ExitShowColumns is called when production showColumns is exited. +func (s *BaseMySqlParserListener) ExitShowColumns(ctx *ShowColumnsContext) {} + +// EnterShowCreateDb is called when production showCreateDb is entered. +func (s *BaseMySqlParserListener) EnterShowCreateDb(ctx *ShowCreateDbContext) {} + +// ExitShowCreateDb is called when production showCreateDb is exited. +func (s *BaseMySqlParserListener) ExitShowCreateDb(ctx *ShowCreateDbContext) {} + +// EnterShowCreateFullIdObject is called when production showCreateFullIdObject is entered. +func (s *BaseMySqlParserListener) EnterShowCreateFullIdObject(ctx *ShowCreateFullIdObjectContext) {} + +// ExitShowCreateFullIdObject is called when production showCreateFullIdObject is exited. +func (s *BaseMySqlParserListener) ExitShowCreateFullIdObject(ctx *ShowCreateFullIdObjectContext) {} + +// EnterShowCreateUser is called when production showCreateUser is entered. +func (s *BaseMySqlParserListener) EnterShowCreateUser(ctx *ShowCreateUserContext) {} + +// ExitShowCreateUser is called when production showCreateUser is exited. +func (s *BaseMySqlParserListener) ExitShowCreateUser(ctx *ShowCreateUserContext) {} + +// EnterShowEngine is called when production showEngine is entered. +func (s *BaseMySqlParserListener) EnterShowEngine(ctx *ShowEngineContext) {} + +// ExitShowEngine is called when production showEngine is exited. +func (s *BaseMySqlParserListener) ExitShowEngine(ctx *ShowEngineContext) {} + +// EnterShowGlobalInfo is called when production showGlobalInfo is entered. +func (s *BaseMySqlParserListener) EnterShowGlobalInfo(ctx *ShowGlobalInfoContext) {} + +// ExitShowGlobalInfo is called when production showGlobalInfo is exited. +func (s *BaseMySqlParserListener) ExitShowGlobalInfo(ctx *ShowGlobalInfoContext) {} + +// EnterShowErrors is called when production showErrors is entered. +func (s *BaseMySqlParserListener) EnterShowErrors(ctx *ShowErrorsContext) {} + +// ExitShowErrors is called when production showErrors is exited. +func (s *BaseMySqlParserListener) ExitShowErrors(ctx *ShowErrorsContext) {} + +// EnterShowCountErrors is called when production showCountErrors is entered. +func (s *BaseMySqlParserListener) EnterShowCountErrors(ctx *ShowCountErrorsContext) {} + +// ExitShowCountErrors is called when production showCountErrors is exited. +func (s *BaseMySqlParserListener) ExitShowCountErrors(ctx *ShowCountErrorsContext) {} + +// EnterShowSchemaFilter is called when production showSchemaFilter is entered. +func (s *BaseMySqlParserListener) EnterShowSchemaFilter(ctx *ShowSchemaFilterContext) {} + +// ExitShowSchemaFilter is called when production showSchemaFilter is exited. +func (s *BaseMySqlParserListener) ExitShowSchemaFilter(ctx *ShowSchemaFilterContext) {} + +// EnterShowRoutine is called when production showRoutine is entered. +func (s *BaseMySqlParserListener) EnterShowRoutine(ctx *ShowRoutineContext) {} + +// ExitShowRoutine is called when production showRoutine is exited. +func (s *BaseMySqlParserListener) ExitShowRoutine(ctx *ShowRoutineContext) {} + +// EnterShowGrants is called when production showGrants is entered. +func (s *BaseMySqlParserListener) EnterShowGrants(ctx *ShowGrantsContext) {} + +// ExitShowGrants is called when production showGrants is exited. +func (s *BaseMySqlParserListener) ExitShowGrants(ctx *ShowGrantsContext) {} + +// EnterShowIndexes is called when production showIndexes is entered. +func (s *BaseMySqlParserListener) EnterShowIndexes(ctx *ShowIndexesContext) {} + +// ExitShowIndexes is called when production showIndexes is exited. +func (s *BaseMySqlParserListener) ExitShowIndexes(ctx *ShowIndexesContext) {} + +// EnterShowOpenTables is called when production showOpenTables is entered. +func (s *BaseMySqlParserListener) EnterShowOpenTables(ctx *ShowOpenTablesContext) {} + +// ExitShowOpenTables is called when production showOpenTables is exited. +func (s *BaseMySqlParserListener) ExitShowOpenTables(ctx *ShowOpenTablesContext) {} + +// EnterShowProfile is called when production showProfile is entered. +func (s *BaseMySqlParserListener) EnterShowProfile(ctx *ShowProfileContext) {} + +// ExitShowProfile is called when production showProfile is exited. +func (s *BaseMySqlParserListener) ExitShowProfile(ctx *ShowProfileContext) {} + +// EnterShowSlaveStatus is called when production showSlaveStatus is entered. +func (s *BaseMySqlParserListener) EnterShowSlaveStatus(ctx *ShowSlaveStatusContext) {} + +// ExitShowSlaveStatus is called when production showSlaveStatus is exited. +func (s *BaseMySqlParserListener) ExitShowSlaveStatus(ctx *ShowSlaveStatusContext) {} + +// EnterVariableClause is called when production variableClause is entered. +func (s *BaseMySqlParserListener) EnterVariableClause(ctx *VariableClauseContext) {} + +// ExitVariableClause is called when production variableClause is exited. +func (s *BaseMySqlParserListener) ExitVariableClause(ctx *VariableClauseContext) {} + +// EnterShowCommonEntity is called when production showCommonEntity is entered. +func (s *BaseMySqlParserListener) EnterShowCommonEntity(ctx *ShowCommonEntityContext) {} + +// ExitShowCommonEntity is called when production showCommonEntity is exited. +func (s *BaseMySqlParserListener) ExitShowCommonEntity(ctx *ShowCommonEntityContext) {} + +// EnterShowFilter is called when production showFilter is entered. +func (s *BaseMySqlParserListener) EnterShowFilter(ctx *ShowFilterContext) {} + +// ExitShowFilter is called when production showFilter is exited. +func (s *BaseMySqlParserListener) ExitShowFilter(ctx *ShowFilterContext) {} + +// EnterShowGlobalInfoClause is called when production showGlobalInfoClause is entered. +func (s *BaseMySqlParserListener) EnterShowGlobalInfoClause(ctx *ShowGlobalInfoClauseContext) {} + +// ExitShowGlobalInfoClause is called when production showGlobalInfoClause is exited. +func (s *BaseMySqlParserListener) ExitShowGlobalInfoClause(ctx *ShowGlobalInfoClauseContext) {} + +// EnterShowSchemaEntity is called when production showSchemaEntity is entered. +func (s *BaseMySqlParserListener) EnterShowSchemaEntity(ctx *ShowSchemaEntityContext) {} + +// ExitShowSchemaEntity is called when production showSchemaEntity is exited. +func (s *BaseMySqlParserListener) ExitShowSchemaEntity(ctx *ShowSchemaEntityContext) {} + +// EnterShowProfileType is called when production showProfileType is entered. +func (s *BaseMySqlParserListener) EnterShowProfileType(ctx *ShowProfileTypeContext) {} + +// ExitShowProfileType is called when production showProfileType is exited. +func (s *BaseMySqlParserListener) ExitShowProfileType(ctx *ShowProfileTypeContext) {} + +// EnterBinlogStatement is called when production binlogStatement is entered. +func (s *BaseMySqlParserListener) EnterBinlogStatement(ctx *BinlogStatementContext) {} + +// ExitBinlogStatement is called when production binlogStatement is exited. +func (s *BaseMySqlParserListener) ExitBinlogStatement(ctx *BinlogStatementContext) {} + +// EnterCacheIndexStatement is called when production cacheIndexStatement is entered. +func (s *BaseMySqlParserListener) EnterCacheIndexStatement(ctx *CacheIndexStatementContext) {} + +// ExitCacheIndexStatement is called when production cacheIndexStatement is exited. +func (s *BaseMySqlParserListener) ExitCacheIndexStatement(ctx *CacheIndexStatementContext) {} + +// EnterFlushStatement is called when production flushStatement is entered. +func (s *BaseMySqlParserListener) EnterFlushStatement(ctx *FlushStatementContext) {} + +// ExitFlushStatement is called when production flushStatement is exited. +func (s *BaseMySqlParserListener) ExitFlushStatement(ctx *FlushStatementContext) {} + +// EnterKillStatement is called when production killStatement is entered. +func (s *BaseMySqlParserListener) EnterKillStatement(ctx *KillStatementContext) {} + +// ExitKillStatement is called when production killStatement is exited. +func (s *BaseMySqlParserListener) ExitKillStatement(ctx *KillStatementContext) {} + +// EnterLoadIndexIntoCache is called when production loadIndexIntoCache is entered. +func (s *BaseMySqlParserListener) EnterLoadIndexIntoCache(ctx *LoadIndexIntoCacheContext) {} + +// ExitLoadIndexIntoCache is called when production loadIndexIntoCache is exited. +func (s *BaseMySqlParserListener) ExitLoadIndexIntoCache(ctx *LoadIndexIntoCacheContext) {} + +// EnterResetStatement is called when production resetStatement is entered. +func (s *BaseMySqlParserListener) EnterResetStatement(ctx *ResetStatementContext) {} + +// ExitResetStatement is called when production resetStatement is exited. +func (s *BaseMySqlParserListener) ExitResetStatement(ctx *ResetStatementContext) {} + +// EnterShutdownStatement is called when production shutdownStatement is entered. +func (s *BaseMySqlParserListener) EnterShutdownStatement(ctx *ShutdownStatementContext) {} + +// ExitShutdownStatement is called when production shutdownStatement is exited. +func (s *BaseMySqlParserListener) ExitShutdownStatement(ctx *ShutdownStatementContext) {} + +// EnterTableIndexes is called when production tableIndexes is entered. +func (s *BaseMySqlParserListener) EnterTableIndexes(ctx *TableIndexesContext) {} + +// ExitTableIndexes is called when production tableIndexes is exited. +func (s *BaseMySqlParserListener) ExitTableIndexes(ctx *TableIndexesContext) {} + +// EnterSimpleFlushOption is called when production simpleFlushOption is entered. +func (s *BaseMySqlParserListener) EnterSimpleFlushOption(ctx *SimpleFlushOptionContext) {} + +// ExitSimpleFlushOption is called when production simpleFlushOption is exited. +func (s *BaseMySqlParserListener) ExitSimpleFlushOption(ctx *SimpleFlushOptionContext) {} + +// EnterChannelFlushOption is called when production channelFlushOption is entered. +func (s *BaseMySqlParserListener) EnterChannelFlushOption(ctx *ChannelFlushOptionContext) {} + +// ExitChannelFlushOption is called when production channelFlushOption is exited. +func (s *BaseMySqlParserListener) ExitChannelFlushOption(ctx *ChannelFlushOptionContext) {} + +// EnterTableFlushOption is called when production tableFlushOption is entered. +func (s *BaseMySqlParserListener) EnterTableFlushOption(ctx *TableFlushOptionContext) {} + +// ExitTableFlushOption is called when production tableFlushOption is exited. +func (s *BaseMySqlParserListener) ExitTableFlushOption(ctx *TableFlushOptionContext) {} + +// EnterFlushTableOption is called when production flushTableOption is entered. +func (s *BaseMySqlParserListener) EnterFlushTableOption(ctx *FlushTableOptionContext) {} + +// ExitFlushTableOption is called when production flushTableOption is exited. +func (s *BaseMySqlParserListener) ExitFlushTableOption(ctx *FlushTableOptionContext) {} + +// EnterLoadedTableIndexes is called when production loadedTableIndexes is entered. +func (s *BaseMySqlParserListener) EnterLoadedTableIndexes(ctx *LoadedTableIndexesContext) {} + +// ExitLoadedTableIndexes is called when production loadedTableIndexes is exited. +func (s *BaseMySqlParserListener) ExitLoadedTableIndexes(ctx *LoadedTableIndexesContext) {} + +// EnterSimpleDescribeStatement is called when production simpleDescribeStatement is entered. +func (s *BaseMySqlParserListener) EnterSimpleDescribeStatement(ctx *SimpleDescribeStatementContext) {} + +// ExitSimpleDescribeStatement is called when production simpleDescribeStatement is exited. +func (s *BaseMySqlParserListener) ExitSimpleDescribeStatement(ctx *SimpleDescribeStatementContext) {} + +// EnterFullDescribeStatement is called when production fullDescribeStatement is entered. +func (s *BaseMySqlParserListener) EnterFullDescribeStatement(ctx *FullDescribeStatementContext) {} + +// ExitFullDescribeStatement is called when production fullDescribeStatement is exited. +func (s *BaseMySqlParserListener) ExitFullDescribeStatement(ctx *FullDescribeStatementContext) {} + +// EnterHelpStatement is called when production helpStatement is entered. +func (s *BaseMySqlParserListener) EnterHelpStatement(ctx *HelpStatementContext) {} + +// ExitHelpStatement is called when production helpStatement is exited. +func (s *BaseMySqlParserListener) ExitHelpStatement(ctx *HelpStatementContext) {} + +// EnterUseStatement is called when production useStatement is entered. +func (s *BaseMySqlParserListener) EnterUseStatement(ctx *UseStatementContext) {} + +// ExitUseStatement is called when production useStatement is exited. +func (s *BaseMySqlParserListener) ExitUseStatement(ctx *UseStatementContext) {} + +// EnterSignalStatement is called when production signalStatement is entered. +func (s *BaseMySqlParserListener) EnterSignalStatement(ctx *SignalStatementContext) {} + +// ExitSignalStatement is called when production signalStatement is exited. +func (s *BaseMySqlParserListener) ExitSignalStatement(ctx *SignalStatementContext) {} + +// EnterResignalStatement is called when production resignalStatement is entered. +func (s *BaseMySqlParserListener) EnterResignalStatement(ctx *ResignalStatementContext) {} + +// ExitResignalStatement is called when production resignalStatement is exited. +func (s *BaseMySqlParserListener) ExitResignalStatement(ctx *ResignalStatementContext) {} + +// EnterSignalConditionInformation is called when production signalConditionInformation is entered. +func (s *BaseMySqlParserListener) EnterSignalConditionInformation(ctx *SignalConditionInformationContext) { +} + +// ExitSignalConditionInformation is called when production signalConditionInformation is exited. +func (s *BaseMySqlParserListener) ExitSignalConditionInformation(ctx *SignalConditionInformationContext) { +} + +// EnterWithStatement is called when production withStatement is entered. +func (s *BaseMySqlParserListener) EnterWithStatement(ctx *WithStatementContext) {} + +// ExitWithStatement is called when production withStatement is exited. +func (s *BaseMySqlParserListener) ExitWithStatement(ctx *WithStatementContext) {} + +// EnterTableStatement is called when production tableStatement is entered. +func (s *BaseMySqlParserListener) EnterTableStatement(ctx *TableStatementContext) {} + +// ExitTableStatement is called when production tableStatement is exited. +func (s *BaseMySqlParserListener) ExitTableStatement(ctx *TableStatementContext) {} + +// EnterDiagnosticsStatement is called when production diagnosticsStatement is entered. +func (s *BaseMySqlParserListener) EnterDiagnosticsStatement(ctx *DiagnosticsStatementContext) {} + +// ExitDiagnosticsStatement is called when production diagnosticsStatement is exited. +func (s *BaseMySqlParserListener) ExitDiagnosticsStatement(ctx *DiagnosticsStatementContext) {} + +// EnterDiagnosticsConditionInformationName is called when production diagnosticsConditionInformationName is entered. +func (s *BaseMySqlParserListener) EnterDiagnosticsConditionInformationName(ctx *DiagnosticsConditionInformationNameContext) { +} + +// ExitDiagnosticsConditionInformationName is called when production diagnosticsConditionInformationName is exited. +func (s *BaseMySqlParserListener) ExitDiagnosticsConditionInformationName(ctx *DiagnosticsConditionInformationNameContext) { +} + +// EnterDescribeStatements is called when production describeStatements is entered. +func (s *BaseMySqlParserListener) EnterDescribeStatements(ctx *DescribeStatementsContext) {} + +// ExitDescribeStatements is called when production describeStatements is exited. +func (s *BaseMySqlParserListener) ExitDescribeStatements(ctx *DescribeStatementsContext) {} + +// EnterDescribeConnection is called when production describeConnection is entered. +func (s *BaseMySqlParserListener) EnterDescribeConnection(ctx *DescribeConnectionContext) {} + +// ExitDescribeConnection is called when production describeConnection is exited. +func (s *BaseMySqlParserListener) ExitDescribeConnection(ctx *DescribeConnectionContext) {} + +// EnterFullId is called when production fullId is entered. +func (s *BaseMySqlParserListener) EnterFullId(ctx *FullIdContext) {} + +// ExitFullId is called when production fullId is exited. +func (s *BaseMySqlParserListener) ExitFullId(ctx *FullIdContext) {} + +// EnterTableName is called when production tableName is entered. +func (s *BaseMySqlParserListener) EnterTableName(ctx *TableNameContext) {} + +// ExitTableName is called when production tableName is exited. +func (s *BaseMySqlParserListener) ExitTableName(ctx *TableNameContext) {} + +// EnterRoleName is called when production roleName is entered. +func (s *BaseMySqlParserListener) EnterRoleName(ctx *RoleNameContext) {} + +// ExitRoleName is called when production roleName is exited. +func (s *BaseMySqlParserListener) ExitRoleName(ctx *RoleNameContext) {} + +// EnterFullColumnName is called when production fullColumnName is entered. +func (s *BaseMySqlParserListener) EnterFullColumnName(ctx *FullColumnNameContext) {} + +// ExitFullColumnName is called when production fullColumnName is exited. +func (s *BaseMySqlParserListener) ExitFullColumnName(ctx *FullColumnNameContext) {} + +// EnterIndexColumnName is called when production indexColumnName is entered. +func (s *BaseMySqlParserListener) EnterIndexColumnName(ctx *IndexColumnNameContext) {} + +// ExitIndexColumnName is called when production indexColumnName is exited. +func (s *BaseMySqlParserListener) ExitIndexColumnName(ctx *IndexColumnNameContext) {} + +// EnterSimpleUserName is called when production simpleUserName is entered. +func (s *BaseMySqlParserListener) EnterSimpleUserName(ctx *SimpleUserNameContext) {} + +// ExitSimpleUserName is called when production simpleUserName is exited. +func (s *BaseMySqlParserListener) ExitSimpleUserName(ctx *SimpleUserNameContext) {} + +// EnterHostName is called when production hostName is entered. +func (s *BaseMySqlParserListener) EnterHostName(ctx *HostNameContext) {} + +// ExitHostName is called when production hostName is exited. +func (s *BaseMySqlParserListener) ExitHostName(ctx *HostNameContext) {} + +// EnterUserName is called when production userName is entered. +func (s *BaseMySqlParserListener) EnterUserName(ctx *UserNameContext) {} + +// ExitUserName is called when production userName is exited. +func (s *BaseMySqlParserListener) ExitUserName(ctx *UserNameContext) {} + +// EnterMysqlVariable is called when production mysqlVariable is entered. +func (s *BaseMySqlParserListener) EnterMysqlVariable(ctx *MysqlVariableContext) {} + +// ExitMysqlVariable is called when production mysqlVariable is exited. +func (s *BaseMySqlParserListener) ExitMysqlVariable(ctx *MysqlVariableContext) {} + +// EnterCharsetName is called when production charsetName is entered. +func (s *BaseMySqlParserListener) EnterCharsetName(ctx *CharsetNameContext) {} + +// ExitCharsetName is called when production charsetName is exited. +func (s *BaseMySqlParserListener) ExitCharsetName(ctx *CharsetNameContext) {} + +// EnterCollationName is called when production collationName is entered. +func (s *BaseMySqlParserListener) EnterCollationName(ctx *CollationNameContext) {} + +// ExitCollationName is called when production collationName is exited. +func (s *BaseMySqlParserListener) ExitCollationName(ctx *CollationNameContext) {} + +// EnterEngineName is called when production engineName is entered. +func (s *BaseMySqlParserListener) EnterEngineName(ctx *EngineNameContext) {} + +// ExitEngineName is called when production engineName is exited. +func (s *BaseMySqlParserListener) ExitEngineName(ctx *EngineNameContext) {} + +// EnterEngineNameBase is called when production engineNameBase is entered. +func (s *BaseMySqlParserListener) EnterEngineNameBase(ctx *EngineNameBaseContext) {} + +// ExitEngineNameBase is called when production engineNameBase is exited. +func (s *BaseMySqlParserListener) ExitEngineNameBase(ctx *EngineNameBaseContext) {} + +// EnterUuidSet is called when production uuidSet is entered. +func (s *BaseMySqlParserListener) EnterUuidSet(ctx *UuidSetContext) {} + +// ExitUuidSet is called when production uuidSet is exited. +func (s *BaseMySqlParserListener) ExitUuidSet(ctx *UuidSetContext) {} + +// EnterXid is called when production xid is entered. +func (s *BaseMySqlParserListener) EnterXid(ctx *XidContext) {} + +// ExitXid is called when production xid is exited. +func (s *BaseMySqlParserListener) ExitXid(ctx *XidContext) {} + +// EnterXuidStringId is called when production xuidStringId is entered. +func (s *BaseMySqlParserListener) EnterXuidStringId(ctx *XuidStringIdContext) {} + +// ExitXuidStringId is called when production xuidStringId is exited. +func (s *BaseMySqlParserListener) ExitXuidStringId(ctx *XuidStringIdContext) {} + +// EnterAuthPlugin is called when production authPlugin is entered. +func (s *BaseMySqlParserListener) EnterAuthPlugin(ctx *AuthPluginContext) {} + +// ExitAuthPlugin is called when production authPlugin is exited. +func (s *BaseMySqlParserListener) ExitAuthPlugin(ctx *AuthPluginContext) {} + +// EnterUid is called when production uid is entered. +func (s *BaseMySqlParserListener) EnterUid(ctx *UidContext) {} + +// ExitUid is called when production uid is exited. +func (s *BaseMySqlParserListener) ExitUid(ctx *UidContext) {} + +// EnterSimpleId is called when production simpleId is entered. +func (s *BaseMySqlParserListener) EnterSimpleId(ctx *SimpleIdContext) {} + +// ExitSimpleId is called when production simpleId is exited. +func (s *BaseMySqlParserListener) ExitSimpleId(ctx *SimpleIdContext) {} + +// EnterDottedId is called when production dottedId is entered. +func (s *BaseMySqlParserListener) EnterDottedId(ctx *DottedIdContext) {} + +// ExitDottedId is called when production dottedId is exited. +func (s *BaseMySqlParserListener) ExitDottedId(ctx *DottedIdContext) {} + +// EnterDecimalLiteral is called when production decimalLiteral is entered. +func (s *BaseMySqlParserListener) EnterDecimalLiteral(ctx *DecimalLiteralContext) {} + +// ExitDecimalLiteral is called when production decimalLiteral is exited. +func (s *BaseMySqlParserListener) ExitDecimalLiteral(ctx *DecimalLiteralContext) {} + +// EnterFileSizeLiteral is called when production fileSizeLiteral is entered. +func (s *BaseMySqlParserListener) EnterFileSizeLiteral(ctx *FileSizeLiteralContext) {} + +// ExitFileSizeLiteral is called when production fileSizeLiteral is exited. +func (s *BaseMySqlParserListener) ExitFileSizeLiteral(ctx *FileSizeLiteralContext) {} + +// EnterStringLiteral is called when production stringLiteral is entered. +func (s *BaseMySqlParserListener) EnterStringLiteral(ctx *StringLiteralContext) {} + +// ExitStringLiteral is called when production stringLiteral is exited. +func (s *BaseMySqlParserListener) ExitStringLiteral(ctx *StringLiteralContext) {} + +// EnterBooleanLiteral is called when production booleanLiteral is entered. +func (s *BaseMySqlParserListener) EnterBooleanLiteral(ctx *BooleanLiteralContext) {} + +// ExitBooleanLiteral is called when production booleanLiteral is exited. +func (s *BaseMySqlParserListener) ExitBooleanLiteral(ctx *BooleanLiteralContext) {} + +// EnterHexadecimalLiteral is called when production hexadecimalLiteral is entered. +func (s *BaseMySqlParserListener) EnterHexadecimalLiteral(ctx *HexadecimalLiteralContext) {} + +// ExitHexadecimalLiteral is called when production hexadecimalLiteral is exited. +func (s *BaseMySqlParserListener) ExitHexadecimalLiteral(ctx *HexadecimalLiteralContext) {} + +// EnterNullNotnull is called when production nullNotnull is entered. +func (s *BaseMySqlParserListener) EnterNullNotnull(ctx *NullNotnullContext) {} + +// ExitNullNotnull is called when production nullNotnull is exited. +func (s *BaseMySqlParserListener) ExitNullNotnull(ctx *NullNotnullContext) {} + +// EnterConstant is called when production constant is entered. +func (s *BaseMySqlParserListener) EnterConstant(ctx *ConstantContext) {} + +// ExitConstant is called when production constant is exited. +func (s *BaseMySqlParserListener) ExitConstant(ctx *ConstantContext) {} + +// EnterStringDataType is called when production stringDataType is entered. +func (s *BaseMySqlParserListener) EnterStringDataType(ctx *StringDataTypeContext) {} + +// ExitStringDataType is called when production stringDataType is exited. +func (s *BaseMySqlParserListener) ExitStringDataType(ctx *StringDataTypeContext) {} + +// EnterNationalVaryingStringDataType is called when production nationalVaryingStringDataType is entered. +func (s *BaseMySqlParserListener) EnterNationalVaryingStringDataType(ctx *NationalVaryingStringDataTypeContext) { +} + +// ExitNationalVaryingStringDataType is called when production nationalVaryingStringDataType is exited. +func (s *BaseMySqlParserListener) ExitNationalVaryingStringDataType(ctx *NationalVaryingStringDataTypeContext) { +} + +// EnterNationalStringDataType is called when production nationalStringDataType is entered. +func (s *BaseMySqlParserListener) EnterNationalStringDataType(ctx *NationalStringDataTypeContext) {} + +// ExitNationalStringDataType is called when production nationalStringDataType is exited. +func (s *BaseMySqlParserListener) ExitNationalStringDataType(ctx *NationalStringDataTypeContext) {} + +// EnterDimensionDataType is called when production dimensionDataType is entered. +func (s *BaseMySqlParserListener) EnterDimensionDataType(ctx *DimensionDataTypeContext) {} + +// ExitDimensionDataType is called when production dimensionDataType is exited. +func (s *BaseMySqlParserListener) ExitDimensionDataType(ctx *DimensionDataTypeContext) {} + +// EnterSimpleDataType is called when production simpleDataType is entered. +func (s *BaseMySqlParserListener) EnterSimpleDataType(ctx *SimpleDataTypeContext) {} + +// ExitSimpleDataType is called when production simpleDataType is exited. +func (s *BaseMySqlParserListener) ExitSimpleDataType(ctx *SimpleDataTypeContext) {} + +// EnterCollectionDataType is called when production collectionDataType is entered. +func (s *BaseMySqlParserListener) EnterCollectionDataType(ctx *CollectionDataTypeContext) {} + +// ExitCollectionDataType is called when production collectionDataType is exited. +func (s *BaseMySqlParserListener) ExitCollectionDataType(ctx *CollectionDataTypeContext) {} + +// EnterSpatialDataType is called when production spatialDataType is entered. +func (s *BaseMySqlParserListener) EnterSpatialDataType(ctx *SpatialDataTypeContext) {} + +// ExitSpatialDataType is called when production spatialDataType is exited. +func (s *BaseMySqlParserListener) ExitSpatialDataType(ctx *SpatialDataTypeContext) {} + +// EnterLongVarcharDataType is called when production longVarcharDataType is entered. +func (s *BaseMySqlParserListener) EnterLongVarcharDataType(ctx *LongVarcharDataTypeContext) {} + +// ExitLongVarcharDataType is called when production longVarcharDataType is exited. +func (s *BaseMySqlParserListener) ExitLongVarcharDataType(ctx *LongVarcharDataTypeContext) {} + +// EnterLongVarbinaryDataType is called when production longVarbinaryDataType is entered. +func (s *BaseMySqlParserListener) EnterLongVarbinaryDataType(ctx *LongVarbinaryDataTypeContext) {} + +// ExitLongVarbinaryDataType is called when production longVarbinaryDataType is exited. +func (s *BaseMySqlParserListener) ExitLongVarbinaryDataType(ctx *LongVarbinaryDataTypeContext) {} + +// EnterCollectionOptions is called when production collectionOptions is entered. +func (s *BaseMySqlParserListener) EnterCollectionOptions(ctx *CollectionOptionsContext) {} + +// ExitCollectionOptions is called when production collectionOptions is exited. +func (s *BaseMySqlParserListener) ExitCollectionOptions(ctx *CollectionOptionsContext) {} + +// EnterConvertedDataType is called when production convertedDataType is entered. +func (s *BaseMySqlParserListener) EnterConvertedDataType(ctx *ConvertedDataTypeContext) {} + +// ExitConvertedDataType is called when production convertedDataType is exited. +func (s *BaseMySqlParserListener) ExitConvertedDataType(ctx *ConvertedDataTypeContext) {} + +// EnterLengthOneDimension is called when production lengthOneDimension is entered. +func (s *BaseMySqlParserListener) EnterLengthOneDimension(ctx *LengthOneDimensionContext) {} + +// ExitLengthOneDimension is called when production lengthOneDimension is exited. +func (s *BaseMySqlParserListener) ExitLengthOneDimension(ctx *LengthOneDimensionContext) {} + +// EnterLengthTwoDimension is called when production lengthTwoDimension is entered. +func (s *BaseMySqlParserListener) EnterLengthTwoDimension(ctx *LengthTwoDimensionContext) {} + +// ExitLengthTwoDimension is called when production lengthTwoDimension is exited. +func (s *BaseMySqlParserListener) ExitLengthTwoDimension(ctx *LengthTwoDimensionContext) {} + +// EnterLengthTwoOptionalDimension is called when production lengthTwoOptionalDimension is entered. +func (s *BaseMySqlParserListener) EnterLengthTwoOptionalDimension(ctx *LengthTwoOptionalDimensionContext) { +} + +// ExitLengthTwoOptionalDimension is called when production lengthTwoOptionalDimension is exited. +func (s *BaseMySqlParserListener) ExitLengthTwoOptionalDimension(ctx *LengthTwoOptionalDimensionContext) { +} + +// EnterUidList is called when production uidList is entered. +func (s *BaseMySqlParserListener) EnterUidList(ctx *UidListContext) {} + +// ExitUidList is called when production uidList is exited. +func (s *BaseMySqlParserListener) ExitUidList(ctx *UidListContext) {} + +// EnterFullColumnNameList is called when production fullColumnNameList is entered. +func (s *BaseMySqlParserListener) EnterFullColumnNameList(ctx *FullColumnNameListContext) {} + +// ExitFullColumnNameList is called when production fullColumnNameList is exited. +func (s *BaseMySqlParserListener) ExitFullColumnNameList(ctx *FullColumnNameListContext) {} + +// EnterTables is called when production tables is entered. +func (s *BaseMySqlParserListener) EnterTables(ctx *TablesContext) {} + +// ExitTables is called when production tables is exited. +func (s *BaseMySqlParserListener) ExitTables(ctx *TablesContext) {} + +// EnterIndexColumnNames is called when production indexColumnNames is entered. +func (s *BaseMySqlParserListener) EnterIndexColumnNames(ctx *IndexColumnNamesContext) {} + +// ExitIndexColumnNames is called when production indexColumnNames is exited. +func (s *BaseMySqlParserListener) ExitIndexColumnNames(ctx *IndexColumnNamesContext) {} + +// EnterExpressions is called when production expressions is entered. +func (s *BaseMySqlParserListener) EnterExpressions(ctx *ExpressionsContext) {} + +// ExitExpressions is called when production expressions is exited. +func (s *BaseMySqlParserListener) ExitExpressions(ctx *ExpressionsContext) {} + +// EnterExpressionsWithDefaults is called when production expressionsWithDefaults is entered. +func (s *BaseMySqlParserListener) EnterExpressionsWithDefaults(ctx *ExpressionsWithDefaultsContext) {} + +// ExitExpressionsWithDefaults is called when production expressionsWithDefaults is exited. +func (s *BaseMySqlParserListener) ExitExpressionsWithDefaults(ctx *ExpressionsWithDefaultsContext) {} + +// EnterConstants is called when production constants is entered. +func (s *BaseMySqlParserListener) EnterConstants(ctx *ConstantsContext) {} + +// ExitConstants is called when production constants is exited. +func (s *BaseMySqlParserListener) ExitConstants(ctx *ConstantsContext) {} + +// EnterSimpleStrings is called when production simpleStrings is entered. +func (s *BaseMySqlParserListener) EnterSimpleStrings(ctx *SimpleStringsContext) {} + +// ExitSimpleStrings is called when production simpleStrings is exited. +func (s *BaseMySqlParserListener) ExitSimpleStrings(ctx *SimpleStringsContext) {} + +// EnterUserVariables is called when production userVariables is entered. +func (s *BaseMySqlParserListener) EnterUserVariables(ctx *UserVariablesContext) {} + +// ExitUserVariables is called when production userVariables is exited. +func (s *BaseMySqlParserListener) ExitUserVariables(ctx *UserVariablesContext) {} + +// EnterDefaultValue is called when production defaultValue is entered. +func (s *BaseMySqlParserListener) EnterDefaultValue(ctx *DefaultValueContext) {} + +// ExitDefaultValue is called when production defaultValue is exited. +func (s *BaseMySqlParserListener) ExitDefaultValue(ctx *DefaultValueContext) {} + +// EnterCurrentTimestamp is called when production currentTimestamp is entered. +func (s *BaseMySqlParserListener) EnterCurrentTimestamp(ctx *CurrentTimestampContext) {} + +// ExitCurrentTimestamp is called when production currentTimestamp is exited. +func (s *BaseMySqlParserListener) ExitCurrentTimestamp(ctx *CurrentTimestampContext) {} + +// EnterExpressionOrDefault is called when production expressionOrDefault is entered. +func (s *BaseMySqlParserListener) EnterExpressionOrDefault(ctx *ExpressionOrDefaultContext) {} + +// ExitExpressionOrDefault is called when production expressionOrDefault is exited. +func (s *BaseMySqlParserListener) ExitExpressionOrDefault(ctx *ExpressionOrDefaultContext) {} + +// EnterIfExists is called when production ifExists is entered. +func (s *BaseMySqlParserListener) EnterIfExists(ctx *IfExistsContext) {} + +// ExitIfExists is called when production ifExists is exited. +func (s *BaseMySqlParserListener) ExitIfExists(ctx *IfExistsContext) {} + +// EnterIfNotExists is called when production ifNotExists is entered. +func (s *BaseMySqlParserListener) EnterIfNotExists(ctx *IfNotExistsContext) {} + +// ExitIfNotExists is called when production ifNotExists is exited. +func (s *BaseMySqlParserListener) ExitIfNotExists(ctx *IfNotExistsContext) {} + +// EnterOrReplace is called when production orReplace is entered. +func (s *BaseMySqlParserListener) EnterOrReplace(ctx *OrReplaceContext) {} + +// ExitOrReplace is called when production orReplace is exited. +func (s *BaseMySqlParserListener) ExitOrReplace(ctx *OrReplaceContext) {} + +// EnterWaitNowaitClause is called when production waitNowaitClause is entered. +func (s *BaseMySqlParserListener) EnterWaitNowaitClause(ctx *WaitNowaitClauseContext) {} + +// ExitWaitNowaitClause is called when production waitNowaitClause is exited. +func (s *BaseMySqlParserListener) ExitWaitNowaitClause(ctx *WaitNowaitClauseContext) {} + +// EnterSpecificFunctionCall is called when production specificFunctionCall is entered. +func (s *BaseMySqlParserListener) EnterSpecificFunctionCall(ctx *SpecificFunctionCallContext) {} + +// ExitSpecificFunctionCall is called when production specificFunctionCall is exited. +func (s *BaseMySqlParserListener) ExitSpecificFunctionCall(ctx *SpecificFunctionCallContext) {} + +// EnterAggregateFunctionCall is called when production aggregateFunctionCall is entered. +func (s *BaseMySqlParserListener) EnterAggregateFunctionCall(ctx *AggregateFunctionCallContext) {} + +// ExitAggregateFunctionCall is called when production aggregateFunctionCall is exited. +func (s *BaseMySqlParserListener) ExitAggregateFunctionCall(ctx *AggregateFunctionCallContext) {} + +// EnterNonAggregateFunctionCall is called when production nonAggregateFunctionCall is entered. +func (s *BaseMySqlParserListener) EnterNonAggregateFunctionCall(ctx *NonAggregateFunctionCallContext) { +} + +// ExitNonAggregateFunctionCall is called when production nonAggregateFunctionCall is exited. +func (s *BaseMySqlParserListener) ExitNonAggregateFunctionCall(ctx *NonAggregateFunctionCallContext) { +} + +// EnterScalarFunctionCall is called when production scalarFunctionCall is entered. +func (s *BaseMySqlParserListener) EnterScalarFunctionCall(ctx *ScalarFunctionCallContext) {} + +// ExitScalarFunctionCall is called when production scalarFunctionCall is exited. +func (s *BaseMySqlParserListener) ExitScalarFunctionCall(ctx *ScalarFunctionCallContext) {} + +// EnterUdfFunctionCall is called when production udfFunctionCall is entered. +func (s *BaseMySqlParserListener) EnterUdfFunctionCall(ctx *UdfFunctionCallContext) {} + +// ExitUdfFunctionCall is called when production udfFunctionCall is exited. +func (s *BaseMySqlParserListener) ExitUdfFunctionCall(ctx *UdfFunctionCallContext) {} + +// EnterPasswordFunctionCall is called when production passwordFunctionCall is entered. +func (s *BaseMySqlParserListener) EnterPasswordFunctionCall(ctx *PasswordFunctionCallContext) {} + +// ExitPasswordFunctionCall is called when production passwordFunctionCall is exited. +func (s *BaseMySqlParserListener) ExitPasswordFunctionCall(ctx *PasswordFunctionCallContext) {} + +// EnterSimpleFunctionCall is called when production simpleFunctionCall is entered. +func (s *BaseMySqlParserListener) EnterSimpleFunctionCall(ctx *SimpleFunctionCallContext) {} + +// ExitSimpleFunctionCall is called when production simpleFunctionCall is exited. +func (s *BaseMySqlParserListener) ExitSimpleFunctionCall(ctx *SimpleFunctionCallContext) {} + +// EnterCurrentUser is called when production currentUser is entered. +func (s *BaseMySqlParserListener) EnterCurrentUser(ctx *CurrentUserContext) {} + +// ExitCurrentUser is called when production currentUser is exited. +func (s *BaseMySqlParserListener) ExitCurrentUser(ctx *CurrentUserContext) {} + +// EnterDataTypeFunctionCall is called when production dataTypeFunctionCall is entered. +func (s *BaseMySqlParserListener) EnterDataTypeFunctionCall(ctx *DataTypeFunctionCallContext) {} + +// ExitDataTypeFunctionCall is called when production dataTypeFunctionCall is exited. +func (s *BaseMySqlParserListener) ExitDataTypeFunctionCall(ctx *DataTypeFunctionCallContext) {} + +// EnterValuesFunctionCall is called when production valuesFunctionCall is entered. +func (s *BaseMySqlParserListener) EnterValuesFunctionCall(ctx *ValuesFunctionCallContext) {} + +// ExitValuesFunctionCall is called when production valuesFunctionCall is exited. +func (s *BaseMySqlParserListener) ExitValuesFunctionCall(ctx *ValuesFunctionCallContext) {} + +// EnterCaseExpressionFunctionCall is called when production caseExpressionFunctionCall is entered. +func (s *BaseMySqlParserListener) EnterCaseExpressionFunctionCall(ctx *CaseExpressionFunctionCallContext) { +} + +// ExitCaseExpressionFunctionCall is called when production caseExpressionFunctionCall is exited. +func (s *BaseMySqlParserListener) ExitCaseExpressionFunctionCall(ctx *CaseExpressionFunctionCallContext) { +} + +// EnterCaseFunctionCall is called when production caseFunctionCall is entered. +func (s *BaseMySqlParserListener) EnterCaseFunctionCall(ctx *CaseFunctionCallContext) {} + +// ExitCaseFunctionCall is called when production caseFunctionCall is exited. +func (s *BaseMySqlParserListener) ExitCaseFunctionCall(ctx *CaseFunctionCallContext) {} + +// EnterCharFunctionCall is called when production charFunctionCall is entered. +func (s *BaseMySqlParserListener) EnterCharFunctionCall(ctx *CharFunctionCallContext) {} + +// ExitCharFunctionCall is called when production charFunctionCall is exited. +func (s *BaseMySqlParserListener) ExitCharFunctionCall(ctx *CharFunctionCallContext) {} + +// EnterPositionFunctionCall is called when production positionFunctionCall is entered. +func (s *BaseMySqlParserListener) EnterPositionFunctionCall(ctx *PositionFunctionCallContext) {} + +// ExitPositionFunctionCall is called when production positionFunctionCall is exited. +func (s *BaseMySqlParserListener) ExitPositionFunctionCall(ctx *PositionFunctionCallContext) {} + +// EnterSubstrFunctionCall is called when production substrFunctionCall is entered. +func (s *BaseMySqlParserListener) EnterSubstrFunctionCall(ctx *SubstrFunctionCallContext) {} + +// ExitSubstrFunctionCall is called when production substrFunctionCall is exited. +func (s *BaseMySqlParserListener) ExitSubstrFunctionCall(ctx *SubstrFunctionCallContext) {} + +// EnterTrimFunctionCall is called when production trimFunctionCall is entered. +func (s *BaseMySqlParserListener) EnterTrimFunctionCall(ctx *TrimFunctionCallContext) {} + +// ExitTrimFunctionCall is called when production trimFunctionCall is exited. +func (s *BaseMySqlParserListener) ExitTrimFunctionCall(ctx *TrimFunctionCallContext) {} + +// EnterWeightFunctionCall is called when production weightFunctionCall is entered. +func (s *BaseMySqlParserListener) EnterWeightFunctionCall(ctx *WeightFunctionCallContext) {} + +// ExitWeightFunctionCall is called when production weightFunctionCall is exited. +func (s *BaseMySqlParserListener) ExitWeightFunctionCall(ctx *WeightFunctionCallContext) {} + +// EnterExtractFunctionCall is called when production extractFunctionCall is entered. +func (s *BaseMySqlParserListener) EnterExtractFunctionCall(ctx *ExtractFunctionCallContext) {} + +// ExitExtractFunctionCall is called when production extractFunctionCall is exited. +func (s *BaseMySqlParserListener) ExitExtractFunctionCall(ctx *ExtractFunctionCallContext) {} + +// EnterGetFormatFunctionCall is called when production getFormatFunctionCall is entered. +func (s *BaseMySqlParserListener) EnterGetFormatFunctionCall(ctx *GetFormatFunctionCallContext) {} + +// ExitGetFormatFunctionCall is called when production getFormatFunctionCall is exited. +func (s *BaseMySqlParserListener) ExitGetFormatFunctionCall(ctx *GetFormatFunctionCallContext) {} + +// EnterJsonValueFunctionCall is called when production jsonValueFunctionCall is entered. +func (s *BaseMySqlParserListener) EnterJsonValueFunctionCall(ctx *JsonValueFunctionCallContext) {} + +// ExitJsonValueFunctionCall is called when production jsonValueFunctionCall is exited. +func (s *BaseMySqlParserListener) ExitJsonValueFunctionCall(ctx *JsonValueFunctionCallContext) {} + +// EnterCaseFuncAlternative is called when production caseFuncAlternative is entered. +func (s *BaseMySqlParserListener) EnterCaseFuncAlternative(ctx *CaseFuncAlternativeContext) {} + +// ExitCaseFuncAlternative is called when production caseFuncAlternative is exited. +func (s *BaseMySqlParserListener) ExitCaseFuncAlternative(ctx *CaseFuncAlternativeContext) {} + +// EnterLevelWeightList is called when production levelWeightList is entered. +func (s *BaseMySqlParserListener) EnterLevelWeightList(ctx *LevelWeightListContext) {} + +// ExitLevelWeightList is called when production levelWeightList is exited. +func (s *BaseMySqlParserListener) ExitLevelWeightList(ctx *LevelWeightListContext) {} + +// EnterLevelWeightRange is called when production levelWeightRange is entered. +func (s *BaseMySqlParserListener) EnterLevelWeightRange(ctx *LevelWeightRangeContext) {} + +// ExitLevelWeightRange is called when production levelWeightRange is exited. +func (s *BaseMySqlParserListener) ExitLevelWeightRange(ctx *LevelWeightRangeContext) {} + +// EnterLevelInWeightListElement is called when production levelInWeightListElement is entered. +func (s *BaseMySqlParserListener) EnterLevelInWeightListElement(ctx *LevelInWeightListElementContext) { +} + +// ExitLevelInWeightListElement is called when production levelInWeightListElement is exited. +func (s *BaseMySqlParserListener) ExitLevelInWeightListElement(ctx *LevelInWeightListElementContext) { +} + +// EnterAggregateWindowedFunction is called when production aggregateWindowedFunction is entered. +func (s *BaseMySqlParserListener) EnterAggregateWindowedFunction(ctx *AggregateWindowedFunctionContext) { +} + +// ExitAggregateWindowedFunction is called when production aggregateWindowedFunction is exited. +func (s *BaseMySqlParserListener) ExitAggregateWindowedFunction(ctx *AggregateWindowedFunctionContext) { +} + +// EnterNonAggregateWindowedFunction is called when production nonAggregateWindowedFunction is entered. +func (s *BaseMySqlParserListener) EnterNonAggregateWindowedFunction(ctx *NonAggregateWindowedFunctionContext) { +} + +// ExitNonAggregateWindowedFunction is called when production nonAggregateWindowedFunction is exited. +func (s *BaseMySqlParserListener) ExitNonAggregateWindowedFunction(ctx *NonAggregateWindowedFunctionContext) { +} + +// EnterOverClause is called when production overClause is entered. +func (s *BaseMySqlParserListener) EnterOverClause(ctx *OverClauseContext) {} + +// ExitOverClause is called when production overClause is exited. +func (s *BaseMySqlParserListener) ExitOverClause(ctx *OverClauseContext) {} + +// EnterWindowSpec is called when production windowSpec is entered. +func (s *BaseMySqlParserListener) EnterWindowSpec(ctx *WindowSpecContext) {} + +// ExitWindowSpec is called when production windowSpec is exited. +func (s *BaseMySqlParserListener) ExitWindowSpec(ctx *WindowSpecContext) {} + +// EnterWindowName is called when production windowName is entered. +func (s *BaseMySqlParserListener) EnterWindowName(ctx *WindowNameContext) {} + +// ExitWindowName is called when production windowName is exited. +func (s *BaseMySqlParserListener) ExitWindowName(ctx *WindowNameContext) {} + +// EnterFrameClause is called when production frameClause is entered. +func (s *BaseMySqlParserListener) EnterFrameClause(ctx *FrameClauseContext) {} + +// ExitFrameClause is called when production frameClause is exited. +func (s *BaseMySqlParserListener) ExitFrameClause(ctx *FrameClauseContext) {} + +// EnterFrameUnits is called when production frameUnits is entered. +func (s *BaseMySqlParserListener) EnterFrameUnits(ctx *FrameUnitsContext) {} + +// ExitFrameUnits is called when production frameUnits is exited. +func (s *BaseMySqlParserListener) ExitFrameUnits(ctx *FrameUnitsContext) {} + +// EnterFrameExtent is called when production frameExtent is entered. +func (s *BaseMySqlParserListener) EnterFrameExtent(ctx *FrameExtentContext) {} + +// ExitFrameExtent is called when production frameExtent is exited. +func (s *BaseMySqlParserListener) ExitFrameExtent(ctx *FrameExtentContext) {} + +// EnterFrameBetween is called when production frameBetween is entered. +func (s *BaseMySqlParserListener) EnterFrameBetween(ctx *FrameBetweenContext) {} + +// ExitFrameBetween is called when production frameBetween is exited. +func (s *BaseMySqlParserListener) ExitFrameBetween(ctx *FrameBetweenContext) {} + +// EnterFrameRange is called when production frameRange is entered. +func (s *BaseMySqlParserListener) EnterFrameRange(ctx *FrameRangeContext) {} + +// ExitFrameRange is called when production frameRange is exited. +func (s *BaseMySqlParserListener) ExitFrameRange(ctx *FrameRangeContext) {} + +// EnterPartitionClause is called when production partitionClause is entered. +func (s *BaseMySqlParserListener) EnterPartitionClause(ctx *PartitionClauseContext) {} + +// ExitPartitionClause is called when production partitionClause is exited. +func (s *BaseMySqlParserListener) ExitPartitionClause(ctx *PartitionClauseContext) {} + +// EnterScalarFunctionName is called when production scalarFunctionName is entered. +func (s *BaseMySqlParserListener) EnterScalarFunctionName(ctx *ScalarFunctionNameContext) {} + +// ExitScalarFunctionName is called when production scalarFunctionName is exited. +func (s *BaseMySqlParserListener) ExitScalarFunctionName(ctx *ScalarFunctionNameContext) {} + +// EnterPasswordFunctionClause is called when production passwordFunctionClause is entered. +func (s *BaseMySqlParserListener) EnterPasswordFunctionClause(ctx *PasswordFunctionClauseContext) {} + +// ExitPasswordFunctionClause is called when production passwordFunctionClause is exited. +func (s *BaseMySqlParserListener) ExitPasswordFunctionClause(ctx *PasswordFunctionClauseContext) {} + +// EnterFunctionArgs is called when production functionArgs is entered. +func (s *BaseMySqlParserListener) EnterFunctionArgs(ctx *FunctionArgsContext) {} + +// ExitFunctionArgs is called when production functionArgs is exited. +func (s *BaseMySqlParserListener) ExitFunctionArgs(ctx *FunctionArgsContext) {} + +// EnterFunctionArg is called when production functionArg is entered. +func (s *BaseMySqlParserListener) EnterFunctionArg(ctx *FunctionArgContext) {} + +// ExitFunctionArg is called when production functionArg is exited. +func (s *BaseMySqlParserListener) ExitFunctionArg(ctx *FunctionArgContext) {} + +// EnterIsExpression is called when production isExpression is entered. +func (s *BaseMySqlParserListener) EnterIsExpression(ctx *IsExpressionContext) {} + +// ExitIsExpression is called when production isExpression is exited. +func (s *BaseMySqlParserListener) ExitIsExpression(ctx *IsExpressionContext) {} + +// EnterNotExpression is called when production notExpression is entered. +func (s *BaseMySqlParserListener) EnterNotExpression(ctx *NotExpressionContext) {} + +// ExitNotExpression is called when production notExpression is exited. +func (s *BaseMySqlParserListener) ExitNotExpression(ctx *NotExpressionContext) {} + +// EnterLogicalExpression is called when production logicalExpression is entered. +func (s *BaseMySqlParserListener) EnterLogicalExpression(ctx *LogicalExpressionContext) {} + +// ExitLogicalExpression is called when production logicalExpression is exited. +func (s *BaseMySqlParserListener) ExitLogicalExpression(ctx *LogicalExpressionContext) {} + +// EnterPredicateExpression is called when production predicateExpression is entered. +func (s *BaseMySqlParserListener) EnterPredicateExpression(ctx *PredicateExpressionContext) {} + +// ExitPredicateExpression is called when production predicateExpression is exited. +func (s *BaseMySqlParserListener) ExitPredicateExpression(ctx *PredicateExpressionContext) {} + +// EnterSoundsLikePredicate is called when production soundsLikePredicate is entered. +func (s *BaseMySqlParserListener) EnterSoundsLikePredicate(ctx *SoundsLikePredicateContext) {} + +// ExitSoundsLikePredicate is called when production soundsLikePredicate is exited. +func (s *BaseMySqlParserListener) ExitSoundsLikePredicate(ctx *SoundsLikePredicateContext) {} + +// EnterExpressionAtomPredicate is called when production expressionAtomPredicate is entered. +func (s *BaseMySqlParserListener) EnterExpressionAtomPredicate(ctx *ExpressionAtomPredicateContext) {} + +// ExitExpressionAtomPredicate is called when production expressionAtomPredicate is exited. +func (s *BaseMySqlParserListener) ExitExpressionAtomPredicate(ctx *ExpressionAtomPredicateContext) {} + +// EnterSubqueryComparisonPredicate is called when production subqueryComparisonPredicate is entered. +func (s *BaseMySqlParserListener) EnterSubqueryComparisonPredicate(ctx *SubqueryComparisonPredicateContext) { +} + +// ExitSubqueryComparisonPredicate is called when production subqueryComparisonPredicate is exited. +func (s *BaseMySqlParserListener) ExitSubqueryComparisonPredicate(ctx *SubqueryComparisonPredicateContext) { +} + +// EnterJsonMemberOfPredicate is called when production jsonMemberOfPredicate is entered. +func (s *BaseMySqlParserListener) EnterJsonMemberOfPredicate(ctx *JsonMemberOfPredicateContext) {} + +// ExitJsonMemberOfPredicate is called when production jsonMemberOfPredicate is exited. +func (s *BaseMySqlParserListener) ExitJsonMemberOfPredicate(ctx *JsonMemberOfPredicateContext) {} + +// EnterBinaryComparisonPredicate is called when production binaryComparisonPredicate is entered. +func (s *BaseMySqlParserListener) EnterBinaryComparisonPredicate(ctx *BinaryComparisonPredicateContext) { +} + +// ExitBinaryComparisonPredicate is called when production binaryComparisonPredicate is exited. +func (s *BaseMySqlParserListener) ExitBinaryComparisonPredicate(ctx *BinaryComparisonPredicateContext) { +} + +// EnterInPredicate is called when production inPredicate is entered. +func (s *BaseMySqlParserListener) EnterInPredicate(ctx *InPredicateContext) {} + +// ExitInPredicate is called when production inPredicate is exited. +func (s *BaseMySqlParserListener) ExitInPredicate(ctx *InPredicateContext) {} + +// EnterBetweenPredicate is called when production betweenPredicate is entered. +func (s *BaseMySqlParserListener) EnterBetweenPredicate(ctx *BetweenPredicateContext) {} + +// ExitBetweenPredicate is called when production betweenPredicate is exited. +func (s *BaseMySqlParserListener) ExitBetweenPredicate(ctx *BetweenPredicateContext) {} + +// EnterIsNullPredicate is called when production isNullPredicate is entered. +func (s *BaseMySqlParserListener) EnterIsNullPredicate(ctx *IsNullPredicateContext) {} + +// ExitIsNullPredicate is called when production isNullPredicate is exited. +func (s *BaseMySqlParserListener) ExitIsNullPredicate(ctx *IsNullPredicateContext) {} + +// EnterLikePredicate is called when production likePredicate is entered. +func (s *BaseMySqlParserListener) EnterLikePredicate(ctx *LikePredicateContext) {} + +// ExitLikePredicate is called when production likePredicate is exited. +func (s *BaseMySqlParserListener) ExitLikePredicate(ctx *LikePredicateContext) {} + +// EnterRegexpPredicate is called when production regexpPredicate is entered. +func (s *BaseMySqlParserListener) EnterRegexpPredicate(ctx *RegexpPredicateContext) {} + +// ExitRegexpPredicate is called when production regexpPredicate is exited. +func (s *BaseMySqlParserListener) ExitRegexpPredicate(ctx *RegexpPredicateContext) {} + +// EnterUnaryExpressionAtom is called when production unaryExpressionAtom is entered. +func (s *BaseMySqlParserListener) EnterUnaryExpressionAtom(ctx *UnaryExpressionAtomContext) {} + +// ExitUnaryExpressionAtom is called when production unaryExpressionAtom is exited. +func (s *BaseMySqlParserListener) ExitUnaryExpressionAtom(ctx *UnaryExpressionAtomContext) {} + +// EnterCollateExpressionAtom is called when production collateExpressionAtom is entered. +func (s *BaseMySqlParserListener) EnterCollateExpressionAtom(ctx *CollateExpressionAtomContext) {} + +// ExitCollateExpressionAtom is called when production collateExpressionAtom is exited. +func (s *BaseMySqlParserListener) ExitCollateExpressionAtom(ctx *CollateExpressionAtomContext) {} + +// EnterVariableAssignExpressionAtom is called when production variableAssignExpressionAtom is entered. +func (s *BaseMySqlParserListener) EnterVariableAssignExpressionAtom(ctx *VariableAssignExpressionAtomContext) { +} + +// ExitVariableAssignExpressionAtom is called when production variableAssignExpressionAtom is exited. +func (s *BaseMySqlParserListener) ExitVariableAssignExpressionAtom(ctx *VariableAssignExpressionAtomContext) { +} + +// EnterMysqlVariableExpressionAtom is called when production mysqlVariableExpressionAtom is entered. +func (s *BaseMySqlParserListener) EnterMysqlVariableExpressionAtom(ctx *MysqlVariableExpressionAtomContext) { +} + +// ExitMysqlVariableExpressionAtom is called when production mysqlVariableExpressionAtom is exited. +func (s *BaseMySqlParserListener) ExitMysqlVariableExpressionAtom(ctx *MysqlVariableExpressionAtomContext) { +} + +// EnterNestedExpressionAtom is called when production nestedExpressionAtom is entered. +func (s *BaseMySqlParserListener) EnterNestedExpressionAtom(ctx *NestedExpressionAtomContext) {} + +// ExitNestedExpressionAtom is called when production nestedExpressionAtom is exited. +func (s *BaseMySqlParserListener) ExitNestedExpressionAtom(ctx *NestedExpressionAtomContext) {} + +// EnterNestedRowExpressionAtom is called when production nestedRowExpressionAtom is entered. +func (s *BaseMySqlParserListener) EnterNestedRowExpressionAtom(ctx *NestedRowExpressionAtomContext) {} + +// ExitNestedRowExpressionAtom is called when production nestedRowExpressionAtom is exited. +func (s *BaseMySqlParserListener) ExitNestedRowExpressionAtom(ctx *NestedRowExpressionAtomContext) {} + +// EnterMathExpressionAtom is called when production mathExpressionAtom is entered. +func (s *BaseMySqlParserListener) EnterMathExpressionAtom(ctx *MathExpressionAtomContext) {} + +// ExitMathExpressionAtom is called when production mathExpressionAtom is exited. +func (s *BaseMySqlParserListener) ExitMathExpressionAtom(ctx *MathExpressionAtomContext) {} + +// EnterExistsExpressionAtom is called when production existsExpressionAtom is entered. +func (s *BaseMySqlParserListener) EnterExistsExpressionAtom(ctx *ExistsExpressionAtomContext) {} + +// ExitExistsExpressionAtom is called when production existsExpressionAtom is exited. +func (s *BaseMySqlParserListener) ExitExistsExpressionAtom(ctx *ExistsExpressionAtomContext) {} + +// EnterIntervalExpressionAtom is called when production intervalExpressionAtom is entered. +func (s *BaseMySqlParserListener) EnterIntervalExpressionAtom(ctx *IntervalExpressionAtomContext) {} + +// ExitIntervalExpressionAtom is called when production intervalExpressionAtom is exited. +func (s *BaseMySqlParserListener) ExitIntervalExpressionAtom(ctx *IntervalExpressionAtomContext) {} + +// EnterJsonExpressionAtom is called when production jsonExpressionAtom is entered. +func (s *BaseMySqlParserListener) EnterJsonExpressionAtom(ctx *JsonExpressionAtomContext) {} + +// ExitJsonExpressionAtom is called when production jsonExpressionAtom is exited. +func (s *BaseMySqlParserListener) ExitJsonExpressionAtom(ctx *JsonExpressionAtomContext) {} + +// EnterSubqueryExpressionAtom is called when production subqueryExpressionAtom is entered. +func (s *BaseMySqlParserListener) EnterSubqueryExpressionAtom(ctx *SubqueryExpressionAtomContext) {} + +// ExitSubqueryExpressionAtom is called when production subqueryExpressionAtom is exited. +func (s *BaseMySqlParserListener) ExitSubqueryExpressionAtom(ctx *SubqueryExpressionAtomContext) {} + +// EnterConstantExpressionAtom is called when production constantExpressionAtom is entered. +func (s *BaseMySqlParserListener) EnterConstantExpressionAtom(ctx *ConstantExpressionAtomContext) {} + +// ExitConstantExpressionAtom is called when production constantExpressionAtom is exited. +func (s *BaseMySqlParserListener) ExitConstantExpressionAtom(ctx *ConstantExpressionAtomContext) {} + +// EnterFunctionCallExpressionAtom is called when production functionCallExpressionAtom is entered. +func (s *BaseMySqlParserListener) EnterFunctionCallExpressionAtom(ctx *FunctionCallExpressionAtomContext) { +} + +// ExitFunctionCallExpressionAtom is called when production functionCallExpressionAtom is exited. +func (s *BaseMySqlParserListener) ExitFunctionCallExpressionAtom(ctx *FunctionCallExpressionAtomContext) { +} + +// EnterBinaryExpressionAtom is called when production binaryExpressionAtom is entered. +func (s *BaseMySqlParserListener) EnterBinaryExpressionAtom(ctx *BinaryExpressionAtomContext) {} + +// ExitBinaryExpressionAtom is called when production binaryExpressionAtom is exited. +func (s *BaseMySqlParserListener) ExitBinaryExpressionAtom(ctx *BinaryExpressionAtomContext) {} + +// EnterFullColumnNameExpressionAtom is called when production fullColumnNameExpressionAtom is entered. +func (s *BaseMySqlParserListener) EnterFullColumnNameExpressionAtom(ctx *FullColumnNameExpressionAtomContext) { +} + +// ExitFullColumnNameExpressionAtom is called when production fullColumnNameExpressionAtom is exited. +func (s *BaseMySqlParserListener) ExitFullColumnNameExpressionAtom(ctx *FullColumnNameExpressionAtomContext) { +} + +// EnterBitExpressionAtom is called when production bitExpressionAtom is entered. +func (s *BaseMySqlParserListener) EnterBitExpressionAtom(ctx *BitExpressionAtomContext) {} + +// ExitBitExpressionAtom is called when production bitExpressionAtom is exited. +func (s *BaseMySqlParserListener) ExitBitExpressionAtom(ctx *BitExpressionAtomContext) {} + +// EnterUnaryOperator is called when production unaryOperator is entered. +func (s *BaseMySqlParserListener) EnterUnaryOperator(ctx *UnaryOperatorContext) {} + +// ExitUnaryOperator is called when production unaryOperator is exited. +func (s *BaseMySqlParserListener) ExitUnaryOperator(ctx *UnaryOperatorContext) {} + +// EnterComparisonOperator is called when production comparisonOperator is entered. +func (s *BaseMySqlParserListener) EnterComparisonOperator(ctx *ComparisonOperatorContext) {} + +// ExitComparisonOperator is called when production comparisonOperator is exited. +func (s *BaseMySqlParserListener) ExitComparisonOperator(ctx *ComparisonOperatorContext) {} + +// EnterLogicalOperator is called when production logicalOperator is entered. +func (s *BaseMySqlParserListener) EnterLogicalOperator(ctx *LogicalOperatorContext) {} + +// ExitLogicalOperator is called when production logicalOperator is exited. +func (s *BaseMySqlParserListener) ExitLogicalOperator(ctx *LogicalOperatorContext) {} + +// EnterBitOperator is called when production bitOperator is entered. +func (s *BaseMySqlParserListener) EnterBitOperator(ctx *BitOperatorContext) {} + +// ExitBitOperator is called when production bitOperator is exited. +func (s *BaseMySqlParserListener) ExitBitOperator(ctx *BitOperatorContext) {} + +// EnterMultOperator is called when production multOperator is entered. +func (s *BaseMySqlParserListener) EnterMultOperator(ctx *MultOperatorContext) {} + +// ExitMultOperator is called when production multOperator is exited. +func (s *BaseMySqlParserListener) ExitMultOperator(ctx *MultOperatorContext) {} + +// EnterAddOperator is called when production addOperator is entered. +func (s *BaseMySqlParserListener) EnterAddOperator(ctx *AddOperatorContext) {} + +// ExitAddOperator is called when production addOperator is exited. +func (s *BaseMySqlParserListener) ExitAddOperator(ctx *AddOperatorContext) {} + +// EnterJsonOperator is called when production jsonOperator is entered. +func (s *BaseMySqlParserListener) EnterJsonOperator(ctx *JsonOperatorContext) {} + +// ExitJsonOperator is called when production jsonOperator is exited. +func (s *BaseMySqlParserListener) ExitJsonOperator(ctx *JsonOperatorContext) {} + +// EnterCharsetNameBase is called when production charsetNameBase is entered. +func (s *BaseMySqlParserListener) EnterCharsetNameBase(ctx *CharsetNameBaseContext) {} + +// ExitCharsetNameBase is called when production charsetNameBase is exited. +func (s *BaseMySqlParserListener) ExitCharsetNameBase(ctx *CharsetNameBaseContext) {} + +// EnterTransactionLevelBase is called when production transactionLevelBase is entered. +func (s *BaseMySqlParserListener) EnterTransactionLevelBase(ctx *TransactionLevelBaseContext) {} + +// ExitTransactionLevelBase is called when production transactionLevelBase is exited. +func (s *BaseMySqlParserListener) ExitTransactionLevelBase(ctx *TransactionLevelBaseContext) {} + +// EnterPrivilegesBase is called when production privilegesBase is entered. +func (s *BaseMySqlParserListener) EnterPrivilegesBase(ctx *PrivilegesBaseContext) {} + +// ExitPrivilegesBase is called when production privilegesBase is exited. +func (s *BaseMySqlParserListener) ExitPrivilegesBase(ctx *PrivilegesBaseContext) {} + +// EnterIntervalTypeBase is called when production intervalTypeBase is entered. +func (s *BaseMySqlParserListener) EnterIntervalTypeBase(ctx *IntervalTypeBaseContext) {} + +// ExitIntervalTypeBase is called when production intervalTypeBase is exited. +func (s *BaseMySqlParserListener) ExitIntervalTypeBase(ctx *IntervalTypeBaseContext) {} + +// EnterDataTypeBase is called when production dataTypeBase is entered. +func (s *BaseMySqlParserListener) EnterDataTypeBase(ctx *DataTypeBaseContext) {} + +// ExitDataTypeBase is called when production dataTypeBase is exited. +func (s *BaseMySqlParserListener) ExitDataTypeBase(ctx *DataTypeBaseContext) {} + +// EnterKeywordsCanBeId is called when production keywordsCanBeId is entered. +func (s *BaseMySqlParserListener) EnterKeywordsCanBeId(ctx *KeywordsCanBeIdContext) {} + +// ExitKeywordsCanBeId is called when production keywordsCanBeId is exited. +func (s *BaseMySqlParserListener) ExitKeywordsCanBeId(ctx *KeywordsCanBeIdContext) {} + +// EnterFunctionNameBase is called when production functionNameBase is entered. +func (s *BaseMySqlParserListener) EnterFunctionNameBase(ctx *FunctionNameBaseContext) {} + +// ExitFunctionNameBase is called when production functionNameBase is exited. +func (s *BaseMySqlParserListener) ExitFunctionNameBase(ctx *FunctionNameBaseContext) {} diff --git a/lib/antlr/generated/mysqlparser_listener.go b/lib/antlr/generated/mysqlparser_listener.go new file mode 100644 index 00000000..cc7a35c4 --- /dev/null +++ b/lib/antlr/generated/mysqlparser_listener.go @@ -0,0 +1,3717 @@ +// Code generated from MySqlParser.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package generated // MySqlParser +import "github.com/antlr4-go/antlr/v4" + +// MySqlParserListener is a complete listener for a parse tree produced by MySqlParser. +type MySqlParserListener interface { + antlr.ParseTreeListener + + // EnterRoot is called when entering the root production. + EnterRoot(c *RootContext) + + // EnterSqlStatements is called when entering the sqlStatements production. + EnterSqlStatements(c *SqlStatementsContext) + + // EnterSqlStatement is called when entering the sqlStatement production. + EnterSqlStatement(c *SqlStatementContext) + + // EnterEmptyStatement_ is called when entering the emptyStatement_ production. + EnterEmptyStatement_(c *EmptyStatement_Context) + + // EnterDdlStatement is called when entering the ddlStatement production. + EnterDdlStatement(c *DdlStatementContext) + + // EnterDmlStatement is called when entering the dmlStatement production. + EnterDmlStatement(c *DmlStatementContext) + + // EnterTransactionStatement is called when entering the transactionStatement production. + EnterTransactionStatement(c *TransactionStatementContext) + + // EnterReplicationStatement is called when entering the replicationStatement production. + EnterReplicationStatement(c *ReplicationStatementContext) + + // EnterPreparedStatement is called when entering the preparedStatement production. + EnterPreparedStatement(c *PreparedStatementContext) + + // EnterCompoundStatement is called when entering the compoundStatement production. + EnterCompoundStatement(c *CompoundStatementContext) + + // EnterAdministrationStatement is called when entering the administrationStatement production. + EnterAdministrationStatement(c *AdministrationStatementContext) + + // EnterUtilityStatement is called when entering the utilityStatement production. + EnterUtilityStatement(c *UtilityStatementContext) + + // EnterCreateDatabase is called when entering the createDatabase production. + EnterCreateDatabase(c *CreateDatabaseContext) + + // EnterCreateEvent is called when entering the createEvent production. + EnterCreateEvent(c *CreateEventContext) + + // EnterCreateIndex is called when entering the createIndex production. + EnterCreateIndex(c *CreateIndexContext) + + // EnterCreateLogfileGroup is called when entering the createLogfileGroup production. + EnterCreateLogfileGroup(c *CreateLogfileGroupContext) + + // EnterCreateProcedure is called when entering the createProcedure production. + EnterCreateProcedure(c *CreateProcedureContext) + + // EnterCreateFunction is called when entering the createFunction production. + EnterCreateFunction(c *CreateFunctionContext) + + // EnterCreateRole is called when entering the createRole production. + EnterCreateRole(c *CreateRoleContext) + + // EnterCreateServer is called when entering the createServer production. + EnterCreateServer(c *CreateServerContext) + + // EnterCopyCreateTable is called when entering the copyCreateTable production. + EnterCopyCreateTable(c *CopyCreateTableContext) + + // EnterQueryCreateTable is called when entering the queryCreateTable production. + EnterQueryCreateTable(c *QueryCreateTableContext) + + // EnterColumnCreateTable is called when entering the columnCreateTable production. + EnterColumnCreateTable(c *ColumnCreateTableContext) + + // EnterCreateTablespaceInnodb is called when entering the createTablespaceInnodb production. + EnterCreateTablespaceInnodb(c *CreateTablespaceInnodbContext) + + // EnterCreateTablespaceNdb is called when entering the createTablespaceNdb production. + EnterCreateTablespaceNdb(c *CreateTablespaceNdbContext) + + // EnterCreateTrigger is called when entering the createTrigger production. + EnterCreateTrigger(c *CreateTriggerContext) + + // EnterWithClause is called when entering the withClause production. + EnterWithClause(c *WithClauseContext) + + // EnterCommonTableExpressions is called when entering the commonTableExpressions production. + EnterCommonTableExpressions(c *CommonTableExpressionsContext) + + // EnterCteName is called when entering the cteName production. + EnterCteName(c *CteNameContext) + + // EnterCteColumnName is called when entering the cteColumnName production. + EnterCteColumnName(c *CteColumnNameContext) + + // EnterCreateView is called when entering the createView production. + EnterCreateView(c *CreateViewContext) + + // EnterCreateDatabaseOption is called when entering the createDatabaseOption production. + EnterCreateDatabaseOption(c *CreateDatabaseOptionContext) + + // EnterCharSet is called when entering the charSet production. + EnterCharSet(c *CharSetContext) + + // EnterCurrentUserExpression is called when entering the currentUserExpression production. + EnterCurrentUserExpression(c *CurrentUserExpressionContext) + + // EnterOwnerStatement is called when entering the ownerStatement production. + EnterOwnerStatement(c *OwnerStatementContext) + + // EnterPreciseSchedule is called when entering the preciseSchedule production. + EnterPreciseSchedule(c *PreciseScheduleContext) + + // EnterIntervalSchedule is called when entering the intervalSchedule production. + EnterIntervalSchedule(c *IntervalScheduleContext) + + // EnterTimestampValue is called when entering the timestampValue production. + EnterTimestampValue(c *TimestampValueContext) + + // EnterIntervalExpr is called when entering the intervalExpr production. + EnterIntervalExpr(c *IntervalExprContext) + + // EnterIntervalType is called when entering the intervalType production. + EnterIntervalType(c *IntervalTypeContext) + + // EnterEnableType is called when entering the enableType production. + EnterEnableType(c *EnableTypeContext) + + // EnterIndexType is called when entering the indexType production. + EnterIndexType(c *IndexTypeContext) + + // EnterIndexOption is called when entering the indexOption production. + EnterIndexOption(c *IndexOptionContext) + + // EnterProcedureParameter is called when entering the procedureParameter production. + EnterProcedureParameter(c *ProcedureParameterContext) + + // EnterFunctionParameter is called when entering the functionParameter production. + EnterFunctionParameter(c *FunctionParameterContext) + + // EnterRoutineComment is called when entering the routineComment production. + EnterRoutineComment(c *RoutineCommentContext) + + // EnterRoutineLanguage is called when entering the routineLanguage production. + EnterRoutineLanguage(c *RoutineLanguageContext) + + // EnterRoutineBehavior is called when entering the routineBehavior production. + EnterRoutineBehavior(c *RoutineBehaviorContext) + + // EnterRoutineData is called when entering the routineData production. + EnterRoutineData(c *RoutineDataContext) + + // EnterRoutineSecurity is called when entering the routineSecurity production. + EnterRoutineSecurity(c *RoutineSecurityContext) + + // EnterServerOption is called when entering the serverOption production. + EnterServerOption(c *ServerOptionContext) + + // EnterCreateDefinitions is called when entering the createDefinitions production. + EnterCreateDefinitions(c *CreateDefinitionsContext) + + // EnterColumnDeclaration is called when entering the columnDeclaration production. + EnterColumnDeclaration(c *ColumnDeclarationContext) + + // EnterConstraintDeclaration is called when entering the constraintDeclaration production. + EnterConstraintDeclaration(c *ConstraintDeclarationContext) + + // EnterIndexDeclaration is called when entering the indexDeclaration production. + EnterIndexDeclaration(c *IndexDeclarationContext) + + // EnterColumnDefinition is called when entering the columnDefinition production. + EnterColumnDefinition(c *ColumnDefinitionContext) + + // EnterNullColumnConstraint is called when entering the nullColumnConstraint production. + EnterNullColumnConstraint(c *NullColumnConstraintContext) + + // EnterDefaultColumnConstraint is called when entering the defaultColumnConstraint production. + EnterDefaultColumnConstraint(c *DefaultColumnConstraintContext) + + // EnterVisibilityColumnConstraint is called when entering the visibilityColumnConstraint production. + EnterVisibilityColumnConstraint(c *VisibilityColumnConstraintContext) + + // EnterInvisibilityColumnConstraint is called when entering the invisibilityColumnConstraint production. + EnterInvisibilityColumnConstraint(c *InvisibilityColumnConstraintContext) + + // EnterAutoIncrementColumnConstraint is called when entering the autoIncrementColumnConstraint production. + EnterAutoIncrementColumnConstraint(c *AutoIncrementColumnConstraintContext) + + // EnterPrimaryKeyColumnConstraint is called when entering the primaryKeyColumnConstraint production. + EnterPrimaryKeyColumnConstraint(c *PrimaryKeyColumnConstraintContext) + + // EnterUniqueKeyColumnConstraint is called when entering the uniqueKeyColumnConstraint production. + EnterUniqueKeyColumnConstraint(c *UniqueKeyColumnConstraintContext) + + // EnterCommentColumnConstraint is called when entering the commentColumnConstraint production. + EnterCommentColumnConstraint(c *CommentColumnConstraintContext) + + // EnterFormatColumnConstraint is called when entering the formatColumnConstraint production. + EnterFormatColumnConstraint(c *FormatColumnConstraintContext) + + // EnterStorageColumnConstraint is called when entering the storageColumnConstraint production. + EnterStorageColumnConstraint(c *StorageColumnConstraintContext) + + // EnterReferenceColumnConstraint is called when entering the referenceColumnConstraint production. + EnterReferenceColumnConstraint(c *ReferenceColumnConstraintContext) + + // EnterCollateColumnConstraint is called when entering the collateColumnConstraint production. + EnterCollateColumnConstraint(c *CollateColumnConstraintContext) + + // EnterGeneratedColumnConstraint is called when entering the generatedColumnConstraint production. + EnterGeneratedColumnConstraint(c *GeneratedColumnConstraintContext) + + // EnterSerialDefaultColumnConstraint is called when entering the serialDefaultColumnConstraint production. + EnterSerialDefaultColumnConstraint(c *SerialDefaultColumnConstraintContext) + + // EnterCheckColumnConstraint is called when entering the checkColumnConstraint production. + EnterCheckColumnConstraint(c *CheckColumnConstraintContext) + + // EnterPrimaryKeyTableConstraint is called when entering the primaryKeyTableConstraint production. + EnterPrimaryKeyTableConstraint(c *PrimaryKeyTableConstraintContext) + + // EnterUniqueKeyTableConstraint is called when entering the uniqueKeyTableConstraint production. + EnterUniqueKeyTableConstraint(c *UniqueKeyTableConstraintContext) + + // EnterForeignKeyTableConstraint is called when entering the foreignKeyTableConstraint production. + EnterForeignKeyTableConstraint(c *ForeignKeyTableConstraintContext) + + // EnterCheckTableConstraint is called when entering the checkTableConstraint production. + EnterCheckTableConstraint(c *CheckTableConstraintContext) + + // EnterReferenceDefinition is called when entering the referenceDefinition production. + EnterReferenceDefinition(c *ReferenceDefinitionContext) + + // EnterReferenceAction is called when entering the referenceAction production. + EnterReferenceAction(c *ReferenceActionContext) + + // EnterReferenceControlType is called when entering the referenceControlType production. + EnterReferenceControlType(c *ReferenceControlTypeContext) + + // EnterSimpleIndexDeclaration is called when entering the simpleIndexDeclaration production. + EnterSimpleIndexDeclaration(c *SimpleIndexDeclarationContext) + + // EnterSpecialIndexDeclaration is called when entering the specialIndexDeclaration production. + EnterSpecialIndexDeclaration(c *SpecialIndexDeclarationContext) + + // EnterTableOptionEngine is called when entering the tableOptionEngine production. + EnterTableOptionEngine(c *TableOptionEngineContext) + + // EnterTableOptionEngineAttribute is called when entering the tableOptionEngineAttribute production. + EnterTableOptionEngineAttribute(c *TableOptionEngineAttributeContext) + + // EnterTableOptionAutoextendSize is called when entering the tableOptionAutoextendSize production. + EnterTableOptionAutoextendSize(c *TableOptionAutoextendSizeContext) + + // EnterTableOptionAutoIncrement is called when entering the tableOptionAutoIncrement production. + EnterTableOptionAutoIncrement(c *TableOptionAutoIncrementContext) + + // EnterTableOptionAverage is called when entering the tableOptionAverage production. + EnterTableOptionAverage(c *TableOptionAverageContext) + + // EnterTableOptionCharset is called when entering the tableOptionCharset production. + EnterTableOptionCharset(c *TableOptionCharsetContext) + + // EnterTableOptionChecksum is called when entering the tableOptionChecksum production. + EnterTableOptionChecksum(c *TableOptionChecksumContext) + + // EnterTableOptionCollate is called when entering the tableOptionCollate production. + EnterTableOptionCollate(c *TableOptionCollateContext) + + // EnterTableOptionComment is called when entering the tableOptionComment production. + EnterTableOptionComment(c *TableOptionCommentContext) + + // EnterTableOptionCompression is called when entering the tableOptionCompression production. + EnterTableOptionCompression(c *TableOptionCompressionContext) + + // EnterTableOptionConnection is called when entering the tableOptionConnection production. + EnterTableOptionConnection(c *TableOptionConnectionContext) + + // EnterTableOptionDataDirectory is called when entering the tableOptionDataDirectory production. + EnterTableOptionDataDirectory(c *TableOptionDataDirectoryContext) + + // EnterTableOptionDelay is called when entering the tableOptionDelay production. + EnterTableOptionDelay(c *TableOptionDelayContext) + + // EnterTableOptionEncryption is called when entering the tableOptionEncryption production. + EnterTableOptionEncryption(c *TableOptionEncryptionContext) + + // EnterTableOptionPageCompressed is called when entering the tableOptionPageCompressed production. + EnterTableOptionPageCompressed(c *TableOptionPageCompressedContext) + + // EnterTableOptionPageCompressionLevel is called when entering the tableOptionPageCompressionLevel production. + EnterTableOptionPageCompressionLevel(c *TableOptionPageCompressionLevelContext) + + // EnterTableOptionEncryptionKeyId is called when entering the tableOptionEncryptionKeyId production. + EnterTableOptionEncryptionKeyId(c *TableOptionEncryptionKeyIdContext) + + // EnterTableOptionIndexDirectory is called when entering the tableOptionIndexDirectory production. + EnterTableOptionIndexDirectory(c *TableOptionIndexDirectoryContext) + + // EnterTableOptionInsertMethod is called when entering the tableOptionInsertMethod production. + EnterTableOptionInsertMethod(c *TableOptionInsertMethodContext) + + // EnterTableOptionKeyBlockSize is called when entering the tableOptionKeyBlockSize production. + EnterTableOptionKeyBlockSize(c *TableOptionKeyBlockSizeContext) + + // EnterTableOptionMaxRows is called when entering the tableOptionMaxRows production. + EnterTableOptionMaxRows(c *TableOptionMaxRowsContext) + + // EnterTableOptionMinRows is called when entering the tableOptionMinRows production. + EnterTableOptionMinRows(c *TableOptionMinRowsContext) + + // EnterTableOptionPackKeys is called when entering the tableOptionPackKeys production. + EnterTableOptionPackKeys(c *TableOptionPackKeysContext) + + // EnterTableOptionPassword is called when entering the tableOptionPassword production. + EnterTableOptionPassword(c *TableOptionPasswordContext) + + // EnterTableOptionRowFormat is called when entering the tableOptionRowFormat production. + EnterTableOptionRowFormat(c *TableOptionRowFormatContext) + + // EnterTableOptionStartTransaction is called when entering the tableOptionStartTransaction production. + EnterTableOptionStartTransaction(c *TableOptionStartTransactionContext) + + // EnterTableOptionSecondaryEngineAttribute is called when entering the tableOptionSecondaryEngineAttribute production. + EnterTableOptionSecondaryEngineAttribute(c *TableOptionSecondaryEngineAttributeContext) + + // EnterTableOptionRecalculation is called when entering the tableOptionRecalculation production. + EnterTableOptionRecalculation(c *TableOptionRecalculationContext) + + // EnterTableOptionPersistent is called when entering the tableOptionPersistent production. + EnterTableOptionPersistent(c *TableOptionPersistentContext) + + // EnterTableOptionSamplePage is called when entering the tableOptionSamplePage production. + EnterTableOptionSamplePage(c *TableOptionSamplePageContext) + + // EnterTableOptionTablespace is called when entering the tableOptionTablespace production. + EnterTableOptionTablespace(c *TableOptionTablespaceContext) + + // EnterTableOptionTableType is called when entering the tableOptionTableType production. + EnterTableOptionTableType(c *TableOptionTableTypeContext) + + // EnterTableOptionTransactional is called when entering the tableOptionTransactional production. + EnterTableOptionTransactional(c *TableOptionTransactionalContext) + + // EnterTableOptionUnion is called when entering the tableOptionUnion production. + EnterTableOptionUnion(c *TableOptionUnionContext) + + // EnterTableType is called when entering the tableType production. + EnterTableType(c *TableTypeContext) + + // EnterTablespaceStorage is called when entering the tablespaceStorage production. + EnterTablespaceStorage(c *TablespaceStorageContext) + + // EnterPartitionDefinitions is called when entering the partitionDefinitions production. + EnterPartitionDefinitions(c *PartitionDefinitionsContext) + + // EnterPartitionFunctionHash is called when entering the partitionFunctionHash production. + EnterPartitionFunctionHash(c *PartitionFunctionHashContext) + + // EnterPartitionFunctionKey is called when entering the partitionFunctionKey production. + EnterPartitionFunctionKey(c *PartitionFunctionKeyContext) + + // EnterPartitionFunctionRange is called when entering the partitionFunctionRange production. + EnterPartitionFunctionRange(c *PartitionFunctionRangeContext) + + // EnterPartitionFunctionList is called when entering the partitionFunctionList production. + EnterPartitionFunctionList(c *PartitionFunctionListContext) + + // EnterSubPartitionFunctionHash is called when entering the subPartitionFunctionHash production. + EnterSubPartitionFunctionHash(c *SubPartitionFunctionHashContext) + + // EnterSubPartitionFunctionKey is called when entering the subPartitionFunctionKey production. + EnterSubPartitionFunctionKey(c *SubPartitionFunctionKeyContext) + + // EnterPartitionComparison is called when entering the partitionComparison production. + EnterPartitionComparison(c *PartitionComparisonContext) + + // EnterPartitionListAtom is called when entering the partitionListAtom production. + EnterPartitionListAtom(c *PartitionListAtomContext) + + // EnterPartitionListVector is called when entering the partitionListVector production. + EnterPartitionListVector(c *PartitionListVectorContext) + + // EnterPartitionSimple is called when entering the partitionSimple production. + EnterPartitionSimple(c *PartitionSimpleContext) + + // EnterPartitionDefinerAtom is called when entering the partitionDefinerAtom production. + EnterPartitionDefinerAtom(c *PartitionDefinerAtomContext) + + // EnterPartitionDefinerVector is called when entering the partitionDefinerVector production. + EnterPartitionDefinerVector(c *PartitionDefinerVectorContext) + + // EnterSubpartitionDefinition is called when entering the subpartitionDefinition production. + EnterSubpartitionDefinition(c *SubpartitionDefinitionContext) + + // EnterPartitionOptionEngine is called when entering the partitionOptionEngine production. + EnterPartitionOptionEngine(c *PartitionOptionEngineContext) + + // EnterPartitionOptionComment is called when entering the partitionOptionComment production. + EnterPartitionOptionComment(c *PartitionOptionCommentContext) + + // EnterPartitionOptionDataDirectory is called when entering the partitionOptionDataDirectory production. + EnterPartitionOptionDataDirectory(c *PartitionOptionDataDirectoryContext) + + // EnterPartitionOptionIndexDirectory is called when entering the partitionOptionIndexDirectory production. + EnterPartitionOptionIndexDirectory(c *PartitionOptionIndexDirectoryContext) + + // EnterPartitionOptionMaxRows is called when entering the partitionOptionMaxRows production. + EnterPartitionOptionMaxRows(c *PartitionOptionMaxRowsContext) + + // EnterPartitionOptionMinRows is called when entering the partitionOptionMinRows production. + EnterPartitionOptionMinRows(c *PartitionOptionMinRowsContext) + + // EnterPartitionOptionTablespace is called when entering the partitionOptionTablespace production. + EnterPartitionOptionTablespace(c *PartitionOptionTablespaceContext) + + // EnterPartitionOptionNodeGroup is called when entering the partitionOptionNodeGroup production. + EnterPartitionOptionNodeGroup(c *PartitionOptionNodeGroupContext) + + // EnterAlterSimpleDatabase is called when entering the alterSimpleDatabase production. + EnterAlterSimpleDatabase(c *AlterSimpleDatabaseContext) + + // EnterAlterUpgradeName is called when entering the alterUpgradeName production. + EnterAlterUpgradeName(c *AlterUpgradeNameContext) + + // EnterAlterEvent is called when entering the alterEvent production. + EnterAlterEvent(c *AlterEventContext) + + // EnterAlterFunction is called when entering the alterFunction production. + EnterAlterFunction(c *AlterFunctionContext) + + // EnterAlterInstance is called when entering the alterInstance production. + EnterAlterInstance(c *AlterInstanceContext) + + // EnterAlterLogfileGroup is called when entering the alterLogfileGroup production. + EnterAlterLogfileGroup(c *AlterLogfileGroupContext) + + // EnterAlterProcedure is called when entering the alterProcedure production. + EnterAlterProcedure(c *AlterProcedureContext) + + // EnterAlterServer is called when entering the alterServer production. + EnterAlterServer(c *AlterServerContext) + + // EnterAlterTable is called when entering the alterTable production. + EnterAlterTable(c *AlterTableContext) + + // EnterAlterTablespace is called when entering the alterTablespace production. + EnterAlterTablespace(c *AlterTablespaceContext) + + // EnterAlterView is called when entering the alterView production. + EnterAlterView(c *AlterViewContext) + + // EnterAlterByTableOption is called when entering the alterByTableOption production. + EnterAlterByTableOption(c *AlterByTableOptionContext) + + // EnterAlterByAddColumn is called when entering the alterByAddColumn production. + EnterAlterByAddColumn(c *AlterByAddColumnContext) + + // EnterAlterByAddColumns is called when entering the alterByAddColumns production. + EnterAlterByAddColumns(c *AlterByAddColumnsContext) + + // EnterAlterByAddIndex is called when entering the alterByAddIndex production. + EnterAlterByAddIndex(c *AlterByAddIndexContext) + + // EnterAlterByAddPrimaryKey is called when entering the alterByAddPrimaryKey production. + EnterAlterByAddPrimaryKey(c *AlterByAddPrimaryKeyContext) + + // EnterAlterByAddUniqueKey is called when entering the alterByAddUniqueKey production. + EnterAlterByAddUniqueKey(c *AlterByAddUniqueKeyContext) + + // EnterAlterByAddSpecialIndex is called when entering the alterByAddSpecialIndex production. + EnterAlterByAddSpecialIndex(c *AlterByAddSpecialIndexContext) + + // EnterAlterByAddForeignKey is called when entering the alterByAddForeignKey production. + EnterAlterByAddForeignKey(c *AlterByAddForeignKeyContext) + + // EnterAlterByAddCheckTableConstraint is called when entering the alterByAddCheckTableConstraint production. + EnterAlterByAddCheckTableConstraint(c *AlterByAddCheckTableConstraintContext) + + // EnterAlterByAlterCheckTableConstraint is called when entering the alterByAlterCheckTableConstraint production. + EnterAlterByAlterCheckTableConstraint(c *AlterByAlterCheckTableConstraintContext) + + // EnterAlterBySetAlgorithm is called when entering the alterBySetAlgorithm production. + EnterAlterBySetAlgorithm(c *AlterBySetAlgorithmContext) + + // EnterAlterByChangeDefault is called when entering the alterByChangeDefault production. + EnterAlterByChangeDefault(c *AlterByChangeDefaultContext) + + // EnterAlterByChangeColumn is called when entering the alterByChangeColumn production. + EnterAlterByChangeColumn(c *AlterByChangeColumnContext) + + // EnterAlterByRenameColumn is called when entering the alterByRenameColumn production. + EnterAlterByRenameColumn(c *AlterByRenameColumnContext) + + // EnterAlterByLock is called when entering the alterByLock production. + EnterAlterByLock(c *AlterByLockContext) + + // EnterAlterByModifyColumn is called when entering the alterByModifyColumn production. + EnterAlterByModifyColumn(c *AlterByModifyColumnContext) + + // EnterAlterByDropColumn is called when entering the alterByDropColumn production. + EnterAlterByDropColumn(c *AlterByDropColumnContext) + + // EnterAlterByDropConstraintCheck is called when entering the alterByDropConstraintCheck production. + EnterAlterByDropConstraintCheck(c *AlterByDropConstraintCheckContext) + + // EnterAlterByDropPrimaryKey is called when entering the alterByDropPrimaryKey production. + EnterAlterByDropPrimaryKey(c *AlterByDropPrimaryKeyContext) + + // EnterAlterByDropIndex is called when entering the alterByDropIndex production. + EnterAlterByDropIndex(c *AlterByDropIndexContext) + + // EnterAlterByRenameIndex is called when entering the alterByRenameIndex production. + EnterAlterByRenameIndex(c *AlterByRenameIndexContext) + + // EnterAlterByAlterColumnDefault is called when entering the alterByAlterColumnDefault production. + EnterAlterByAlterColumnDefault(c *AlterByAlterColumnDefaultContext) + + // EnterAlterByAlterIndexVisibility is called when entering the alterByAlterIndexVisibility production. + EnterAlterByAlterIndexVisibility(c *AlterByAlterIndexVisibilityContext) + + // EnterAlterByDropForeignKey is called when entering the alterByDropForeignKey production. + EnterAlterByDropForeignKey(c *AlterByDropForeignKeyContext) + + // EnterAlterByDisableKeys is called when entering the alterByDisableKeys production. + EnterAlterByDisableKeys(c *AlterByDisableKeysContext) + + // EnterAlterByEnableKeys is called when entering the alterByEnableKeys production. + EnterAlterByEnableKeys(c *AlterByEnableKeysContext) + + // EnterAlterByRename is called when entering the alterByRename production. + EnterAlterByRename(c *AlterByRenameContext) + + // EnterAlterByOrder is called when entering the alterByOrder production. + EnterAlterByOrder(c *AlterByOrderContext) + + // EnterAlterByConvertCharset is called when entering the alterByConvertCharset production. + EnterAlterByConvertCharset(c *AlterByConvertCharsetContext) + + // EnterAlterByDefaultCharset is called when entering the alterByDefaultCharset production. + EnterAlterByDefaultCharset(c *AlterByDefaultCharsetContext) + + // EnterAlterByDiscardTablespace is called when entering the alterByDiscardTablespace production. + EnterAlterByDiscardTablespace(c *AlterByDiscardTablespaceContext) + + // EnterAlterByImportTablespace is called when entering the alterByImportTablespace production. + EnterAlterByImportTablespace(c *AlterByImportTablespaceContext) + + // EnterAlterByForce is called when entering the alterByForce production. + EnterAlterByForce(c *AlterByForceContext) + + // EnterAlterByValidate is called when entering the alterByValidate production. + EnterAlterByValidate(c *AlterByValidateContext) + + // EnterAlterByAddDefinitions is called when entering the alterByAddDefinitions production. + EnterAlterByAddDefinitions(c *AlterByAddDefinitionsContext) + + // EnterAlterPartition is called when entering the alterPartition production. + EnterAlterPartition(c *AlterPartitionContext) + + // EnterAlterByAddPartition is called when entering the alterByAddPartition production. + EnterAlterByAddPartition(c *AlterByAddPartitionContext) + + // EnterAlterByDropPartition is called when entering the alterByDropPartition production. + EnterAlterByDropPartition(c *AlterByDropPartitionContext) + + // EnterAlterByDiscardPartition is called when entering the alterByDiscardPartition production. + EnterAlterByDiscardPartition(c *AlterByDiscardPartitionContext) + + // EnterAlterByImportPartition is called when entering the alterByImportPartition production. + EnterAlterByImportPartition(c *AlterByImportPartitionContext) + + // EnterAlterByTruncatePartition is called when entering the alterByTruncatePartition production. + EnterAlterByTruncatePartition(c *AlterByTruncatePartitionContext) + + // EnterAlterByCoalescePartition is called when entering the alterByCoalescePartition production. + EnterAlterByCoalescePartition(c *AlterByCoalescePartitionContext) + + // EnterAlterByReorganizePartition is called when entering the alterByReorganizePartition production. + EnterAlterByReorganizePartition(c *AlterByReorganizePartitionContext) + + // EnterAlterByExchangePartition is called when entering the alterByExchangePartition production. + EnterAlterByExchangePartition(c *AlterByExchangePartitionContext) + + // EnterAlterByAnalyzePartition is called when entering the alterByAnalyzePartition production. + EnterAlterByAnalyzePartition(c *AlterByAnalyzePartitionContext) + + // EnterAlterByCheckPartition is called when entering the alterByCheckPartition production. + EnterAlterByCheckPartition(c *AlterByCheckPartitionContext) + + // EnterAlterByOptimizePartition is called when entering the alterByOptimizePartition production. + EnterAlterByOptimizePartition(c *AlterByOptimizePartitionContext) + + // EnterAlterByRebuildPartition is called when entering the alterByRebuildPartition production. + EnterAlterByRebuildPartition(c *AlterByRebuildPartitionContext) + + // EnterAlterByRepairPartition is called when entering the alterByRepairPartition production. + EnterAlterByRepairPartition(c *AlterByRepairPartitionContext) + + // EnterAlterByRemovePartitioning is called when entering the alterByRemovePartitioning production. + EnterAlterByRemovePartitioning(c *AlterByRemovePartitioningContext) + + // EnterAlterByUpgradePartitioning is called when entering the alterByUpgradePartitioning production. + EnterAlterByUpgradePartitioning(c *AlterByUpgradePartitioningContext) + + // EnterDropDatabase is called when entering the dropDatabase production. + EnterDropDatabase(c *DropDatabaseContext) + + // EnterDropEvent is called when entering the dropEvent production. + EnterDropEvent(c *DropEventContext) + + // EnterDropIndex is called when entering the dropIndex production. + EnterDropIndex(c *DropIndexContext) + + // EnterDropLogfileGroup is called when entering the dropLogfileGroup production. + EnterDropLogfileGroup(c *DropLogfileGroupContext) + + // EnterDropProcedure is called when entering the dropProcedure production. + EnterDropProcedure(c *DropProcedureContext) + + // EnterDropFunction is called when entering the dropFunction production. + EnterDropFunction(c *DropFunctionContext) + + // EnterDropServer is called when entering the dropServer production. + EnterDropServer(c *DropServerContext) + + // EnterDropTable is called when entering the dropTable production. + EnterDropTable(c *DropTableContext) + + // EnterDropTablespace is called when entering the dropTablespace production. + EnterDropTablespace(c *DropTablespaceContext) + + // EnterDropTrigger is called when entering the dropTrigger production. + EnterDropTrigger(c *DropTriggerContext) + + // EnterDropView is called when entering the dropView production. + EnterDropView(c *DropViewContext) + + // EnterDropRole is called when entering the dropRole production. + EnterDropRole(c *DropRoleContext) + + // EnterSetRole is called when entering the setRole production. + EnterSetRole(c *SetRoleContext) + + // EnterRenameTable is called when entering the renameTable production. + EnterRenameTable(c *RenameTableContext) + + // EnterRenameTableClause is called when entering the renameTableClause production. + EnterRenameTableClause(c *RenameTableClauseContext) + + // EnterTruncateTable is called when entering the truncateTable production. + EnterTruncateTable(c *TruncateTableContext) + + // EnterCallStatement is called when entering the callStatement production. + EnterCallStatement(c *CallStatementContext) + + // EnterDeleteStatement is called when entering the deleteStatement production. + EnterDeleteStatement(c *DeleteStatementContext) + + // EnterDoStatement is called when entering the doStatement production. + EnterDoStatement(c *DoStatementContext) + + // EnterHandlerStatement is called when entering the handlerStatement production. + EnterHandlerStatement(c *HandlerStatementContext) + + // EnterInsertStatement is called when entering the insertStatement production. + EnterInsertStatement(c *InsertStatementContext) + + // EnterLoadDataStatement is called when entering the loadDataStatement production. + EnterLoadDataStatement(c *LoadDataStatementContext) + + // EnterLoadXmlStatement is called when entering the loadXmlStatement production. + EnterLoadXmlStatement(c *LoadXmlStatementContext) + + // EnterReplaceStatement is called when entering the replaceStatement production. + EnterReplaceStatement(c *ReplaceStatementContext) + + // EnterSimpleSelect is called when entering the simpleSelect production. + EnterSimpleSelect(c *SimpleSelectContext) + + // EnterParenthesisSelect is called when entering the parenthesisSelect production. + EnterParenthesisSelect(c *ParenthesisSelectContext) + + // EnterUnionSelect is called when entering the unionSelect production. + EnterUnionSelect(c *UnionSelectContext) + + // EnterUnionParenthesisSelect is called when entering the unionParenthesisSelect production. + EnterUnionParenthesisSelect(c *UnionParenthesisSelectContext) + + // EnterWithLateralStatement is called when entering the withLateralStatement production. + EnterWithLateralStatement(c *WithLateralStatementContext) + + // EnterUpdateStatement is called when entering the updateStatement production. + EnterUpdateStatement(c *UpdateStatementContext) + + // EnterValuesStatement is called when entering the valuesStatement production. + EnterValuesStatement(c *ValuesStatementContext) + + // EnterInsertStatementValue is called when entering the insertStatementValue production. + EnterInsertStatementValue(c *InsertStatementValueContext) + + // EnterUpdatedElement is called when entering the updatedElement production. + EnterUpdatedElement(c *UpdatedElementContext) + + // EnterAssignmentField is called when entering the assignmentField production. + EnterAssignmentField(c *AssignmentFieldContext) + + // EnterLockClause is called when entering the lockClause production. + EnterLockClause(c *LockClauseContext) + + // EnterSingleDeleteStatement is called when entering the singleDeleteStatement production. + EnterSingleDeleteStatement(c *SingleDeleteStatementContext) + + // EnterMultipleDeleteStatement is called when entering the multipleDeleteStatement production. + EnterMultipleDeleteStatement(c *MultipleDeleteStatementContext) + + // EnterHandlerOpenStatement is called when entering the handlerOpenStatement production. + EnterHandlerOpenStatement(c *HandlerOpenStatementContext) + + // EnterHandlerReadIndexStatement is called when entering the handlerReadIndexStatement production. + EnterHandlerReadIndexStatement(c *HandlerReadIndexStatementContext) + + // EnterHandlerReadStatement is called when entering the handlerReadStatement production. + EnterHandlerReadStatement(c *HandlerReadStatementContext) + + // EnterHandlerCloseStatement is called when entering the handlerCloseStatement production. + EnterHandlerCloseStatement(c *HandlerCloseStatementContext) + + // EnterSingleUpdateStatement is called when entering the singleUpdateStatement production. + EnterSingleUpdateStatement(c *SingleUpdateStatementContext) + + // EnterMultipleUpdateStatement is called when entering the multipleUpdateStatement production. + EnterMultipleUpdateStatement(c *MultipleUpdateStatementContext) + + // EnterOrderByClause is called when entering the orderByClause production. + EnterOrderByClause(c *OrderByClauseContext) + + // EnterOrderByExpression is called when entering the orderByExpression production. + EnterOrderByExpression(c *OrderByExpressionContext) + + // EnterTableSources is called when entering the tableSources production. + EnterTableSources(c *TableSourcesContext) + + // EnterTableSourceBase is called when entering the tableSourceBase production. + EnterTableSourceBase(c *TableSourceBaseContext) + + // EnterTableSourceNested is called when entering the tableSourceNested production. + EnterTableSourceNested(c *TableSourceNestedContext) + + // EnterTableJson is called when entering the tableJson production. + EnterTableJson(c *TableJsonContext) + + // EnterAtomTableItem is called when entering the atomTableItem production. + EnterAtomTableItem(c *AtomTableItemContext) + + // EnterSubqueryTableItem is called when entering the subqueryTableItem production. + EnterSubqueryTableItem(c *SubqueryTableItemContext) + + // EnterTableSourcesItem is called when entering the tableSourcesItem production. + EnterTableSourcesItem(c *TableSourcesItemContext) + + // EnterIndexHint is called when entering the indexHint production. + EnterIndexHint(c *IndexHintContext) + + // EnterIndexHintType is called when entering the indexHintType production. + EnterIndexHintType(c *IndexHintTypeContext) + + // EnterInnerJoin is called when entering the innerJoin production. + EnterInnerJoin(c *InnerJoinContext) + + // EnterStraightJoin is called when entering the straightJoin production. + EnterStraightJoin(c *StraightJoinContext) + + // EnterOuterJoin is called when entering the outerJoin production. + EnterOuterJoin(c *OuterJoinContext) + + // EnterNaturalJoin is called when entering the naturalJoin production. + EnterNaturalJoin(c *NaturalJoinContext) + + // EnterJoinSpec is called when entering the joinSpec production. + EnterJoinSpec(c *JoinSpecContext) + + // EnterQueryExpression is called when entering the queryExpression production. + EnterQueryExpression(c *QueryExpressionContext) + + // EnterQueryExpressionNointo is called when entering the queryExpressionNointo production. + EnterQueryExpressionNointo(c *QueryExpressionNointoContext) + + // EnterQuerySpecification is called when entering the querySpecification production. + EnterQuerySpecification(c *QuerySpecificationContext) + + // EnterQuerySpecificationNointo is called when entering the querySpecificationNointo production. + EnterQuerySpecificationNointo(c *QuerySpecificationNointoContext) + + // EnterUnionParenthesis is called when entering the unionParenthesis production. + EnterUnionParenthesis(c *UnionParenthesisContext) + + // EnterUnionStatement is called when entering the unionStatement production. + EnterUnionStatement(c *UnionStatementContext) + + // EnterLateralStatement is called when entering the lateralStatement production. + EnterLateralStatement(c *LateralStatementContext) + + // EnterJsonTable is called when entering the jsonTable production. + EnterJsonTable(c *JsonTableContext) + + // EnterJsonColumnList is called when entering the jsonColumnList production. + EnterJsonColumnList(c *JsonColumnListContext) + + // EnterJsonColumn is called when entering the jsonColumn production. + EnterJsonColumn(c *JsonColumnContext) + + // EnterJsonOnEmpty is called when entering the jsonOnEmpty production. + EnterJsonOnEmpty(c *JsonOnEmptyContext) + + // EnterJsonOnError is called when entering the jsonOnError production. + EnterJsonOnError(c *JsonOnErrorContext) + + // EnterSelectSpec is called when entering the selectSpec production. + EnterSelectSpec(c *SelectSpecContext) + + // EnterSelectElements is called when entering the selectElements production. + EnterSelectElements(c *SelectElementsContext) + + // EnterSelectStarElement is called when entering the selectStarElement production. + EnterSelectStarElement(c *SelectStarElementContext) + + // EnterSelectColumnElement is called when entering the selectColumnElement production. + EnterSelectColumnElement(c *SelectColumnElementContext) + + // EnterSelectFunctionElement is called when entering the selectFunctionElement production. + EnterSelectFunctionElement(c *SelectFunctionElementContext) + + // EnterSelectExpressionElement is called when entering the selectExpressionElement production. + EnterSelectExpressionElement(c *SelectExpressionElementContext) + + // EnterSelectIntoVariables is called when entering the selectIntoVariables production. + EnterSelectIntoVariables(c *SelectIntoVariablesContext) + + // EnterSelectIntoDumpFile is called when entering the selectIntoDumpFile production. + EnterSelectIntoDumpFile(c *SelectIntoDumpFileContext) + + // EnterSelectIntoTextFile is called when entering the selectIntoTextFile production. + EnterSelectIntoTextFile(c *SelectIntoTextFileContext) + + // EnterSelectFieldsInto is called when entering the selectFieldsInto production. + EnterSelectFieldsInto(c *SelectFieldsIntoContext) + + // EnterSelectLinesInto is called when entering the selectLinesInto production. + EnterSelectLinesInto(c *SelectLinesIntoContext) + + // EnterFromClause is called when entering the fromClause production. + EnterFromClause(c *FromClauseContext) + + // EnterGroupByClause is called when entering the groupByClause production. + EnterGroupByClause(c *GroupByClauseContext) + + // EnterHavingClause is called when entering the havingClause production. + EnterHavingClause(c *HavingClauseContext) + + // EnterWindowClause is called when entering the windowClause production. + EnterWindowClause(c *WindowClauseContext) + + // EnterGroupByItem is called when entering the groupByItem production. + EnterGroupByItem(c *GroupByItemContext) + + // EnterLimitClause is called when entering the limitClause production. + EnterLimitClause(c *LimitClauseContext) + + // EnterLimitClauseAtom is called when entering the limitClauseAtom production. + EnterLimitClauseAtom(c *LimitClauseAtomContext) + + // EnterStartTransaction is called when entering the startTransaction production. + EnterStartTransaction(c *StartTransactionContext) + + // EnterBeginWork is called when entering the beginWork production. + EnterBeginWork(c *BeginWorkContext) + + // EnterCommitWork is called when entering the commitWork production. + EnterCommitWork(c *CommitWorkContext) + + // EnterRollbackWork is called when entering the rollbackWork production. + EnterRollbackWork(c *RollbackWorkContext) + + // EnterSavepointStatement is called when entering the savepointStatement production. + EnterSavepointStatement(c *SavepointStatementContext) + + // EnterRollbackStatement is called when entering the rollbackStatement production. + EnterRollbackStatement(c *RollbackStatementContext) + + // EnterReleaseStatement is called when entering the releaseStatement production. + EnterReleaseStatement(c *ReleaseStatementContext) + + // EnterLockTables is called when entering the lockTables production. + EnterLockTables(c *LockTablesContext) + + // EnterUnlockTables is called when entering the unlockTables production. + EnterUnlockTables(c *UnlockTablesContext) + + // EnterSetAutocommitStatement is called when entering the setAutocommitStatement production. + EnterSetAutocommitStatement(c *SetAutocommitStatementContext) + + // EnterSetTransactionStatement is called when entering the setTransactionStatement production. + EnterSetTransactionStatement(c *SetTransactionStatementContext) + + // EnterTransactionMode is called when entering the transactionMode production. + EnterTransactionMode(c *TransactionModeContext) + + // EnterLockTableElement is called when entering the lockTableElement production. + EnterLockTableElement(c *LockTableElementContext) + + // EnterLockAction is called when entering the lockAction production. + EnterLockAction(c *LockActionContext) + + // EnterTransactionOption is called when entering the transactionOption production. + EnterTransactionOption(c *TransactionOptionContext) + + // EnterTransactionLevel is called when entering the transactionLevel production. + EnterTransactionLevel(c *TransactionLevelContext) + + // EnterChangeMaster is called when entering the changeMaster production. + EnterChangeMaster(c *ChangeMasterContext) + + // EnterChangeReplicationFilter is called when entering the changeReplicationFilter production. + EnterChangeReplicationFilter(c *ChangeReplicationFilterContext) + + // EnterPurgeBinaryLogs is called when entering the purgeBinaryLogs production. + EnterPurgeBinaryLogs(c *PurgeBinaryLogsContext) + + // EnterResetMaster is called when entering the resetMaster production. + EnterResetMaster(c *ResetMasterContext) + + // EnterResetSlave is called when entering the resetSlave production. + EnterResetSlave(c *ResetSlaveContext) + + // EnterStartSlave is called when entering the startSlave production. + EnterStartSlave(c *StartSlaveContext) + + // EnterStopSlave is called when entering the stopSlave production. + EnterStopSlave(c *StopSlaveContext) + + // EnterStartGroupReplication is called when entering the startGroupReplication production. + EnterStartGroupReplication(c *StartGroupReplicationContext) + + // EnterStopGroupReplication is called when entering the stopGroupReplication production. + EnterStopGroupReplication(c *StopGroupReplicationContext) + + // EnterMasterStringOption is called when entering the masterStringOption production. + EnterMasterStringOption(c *MasterStringOptionContext) + + // EnterMasterDecimalOption is called when entering the masterDecimalOption production. + EnterMasterDecimalOption(c *MasterDecimalOptionContext) + + // EnterMasterBoolOption is called when entering the masterBoolOption production. + EnterMasterBoolOption(c *MasterBoolOptionContext) + + // EnterMasterRealOption is called when entering the masterRealOption production. + EnterMasterRealOption(c *MasterRealOptionContext) + + // EnterMasterUidListOption is called when entering the masterUidListOption production. + EnterMasterUidListOption(c *MasterUidListOptionContext) + + // EnterStringMasterOption is called when entering the stringMasterOption production. + EnterStringMasterOption(c *StringMasterOptionContext) + + // EnterDecimalMasterOption is called when entering the decimalMasterOption production. + EnterDecimalMasterOption(c *DecimalMasterOptionContext) + + // EnterBoolMasterOption is called when entering the boolMasterOption production. + EnterBoolMasterOption(c *BoolMasterOptionContext) + + // EnterChannelOption is called when entering the channelOption production. + EnterChannelOption(c *ChannelOptionContext) + + // EnterDoDbReplication is called when entering the doDbReplication production. + EnterDoDbReplication(c *DoDbReplicationContext) + + // EnterIgnoreDbReplication is called when entering the ignoreDbReplication production. + EnterIgnoreDbReplication(c *IgnoreDbReplicationContext) + + // EnterDoTableReplication is called when entering the doTableReplication production. + EnterDoTableReplication(c *DoTableReplicationContext) + + // EnterIgnoreTableReplication is called when entering the ignoreTableReplication production. + EnterIgnoreTableReplication(c *IgnoreTableReplicationContext) + + // EnterWildDoTableReplication is called when entering the wildDoTableReplication production. + EnterWildDoTableReplication(c *WildDoTableReplicationContext) + + // EnterWildIgnoreTableReplication is called when entering the wildIgnoreTableReplication production. + EnterWildIgnoreTableReplication(c *WildIgnoreTableReplicationContext) + + // EnterRewriteDbReplication is called when entering the rewriteDbReplication production. + EnterRewriteDbReplication(c *RewriteDbReplicationContext) + + // EnterTablePair is called when entering the tablePair production. + EnterTablePair(c *TablePairContext) + + // EnterThreadType is called when entering the threadType production. + EnterThreadType(c *ThreadTypeContext) + + // EnterGtidsUntilOption is called when entering the gtidsUntilOption production. + EnterGtidsUntilOption(c *GtidsUntilOptionContext) + + // EnterMasterLogUntilOption is called when entering the masterLogUntilOption production. + EnterMasterLogUntilOption(c *MasterLogUntilOptionContext) + + // EnterRelayLogUntilOption is called when entering the relayLogUntilOption production. + EnterRelayLogUntilOption(c *RelayLogUntilOptionContext) + + // EnterSqlGapsUntilOption is called when entering the sqlGapsUntilOption production. + EnterSqlGapsUntilOption(c *SqlGapsUntilOptionContext) + + // EnterUserConnectionOption is called when entering the userConnectionOption production. + EnterUserConnectionOption(c *UserConnectionOptionContext) + + // EnterPasswordConnectionOption is called when entering the passwordConnectionOption production. + EnterPasswordConnectionOption(c *PasswordConnectionOptionContext) + + // EnterDefaultAuthConnectionOption is called when entering the defaultAuthConnectionOption production. + EnterDefaultAuthConnectionOption(c *DefaultAuthConnectionOptionContext) + + // EnterPluginDirConnectionOption is called when entering the pluginDirConnectionOption production. + EnterPluginDirConnectionOption(c *PluginDirConnectionOptionContext) + + // EnterGtuidSet is called when entering the gtuidSet production. + EnterGtuidSet(c *GtuidSetContext) + + // EnterXaStartTransaction is called when entering the xaStartTransaction production. + EnterXaStartTransaction(c *XaStartTransactionContext) + + // EnterXaEndTransaction is called when entering the xaEndTransaction production. + EnterXaEndTransaction(c *XaEndTransactionContext) + + // EnterXaPrepareStatement is called when entering the xaPrepareStatement production. + EnterXaPrepareStatement(c *XaPrepareStatementContext) + + // EnterXaCommitWork is called when entering the xaCommitWork production. + EnterXaCommitWork(c *XaCommitWorkContext) + + // EnterXaRollbackWork is called when entering the xaRollbackWork production. + EnterXaRollbackWork(c *XaRollbackWorkContext) + + // EnterXaRecoverWork is called when entering the xaRecoverWork production. + EnterXaRecoverWork(c *XaRecoverWorkContext) + + // EnterPrepareStatement is called when entering the prepareStatement production. + EnterPrepareStatement(c *PrepareStatementContext) + + // EnterExecuteStatement is called when entering the executeStatement production. + EnterExecuteStatement(c *ExecuteStatementContext) + + // EnterDeallocatePrepare is called when entering the deallocatePrepare production. + EnterDeallocatePrepare(c *DeallocatePrepareContext) + + // EnterRoutineBody is called when entering the routineBody production. + EnterRoutineBody(c *RoutineBodyContext) + + // EnterBlockStatement is called when entering the blockStatement production. + EnterBlockStatement(c *BlockStatementContext) + + // EnterCaseStatement is called when entering the caseStatement production. + EnterCaseStatement(c *CaseStatementContext) + + // EnterIfStatement is called when entering the ifStatement production. + EnterIfStatement(c *IfStatementContext) + + // EnterIterateStatement is called when entering the iterateStatement production. + EnterIterateStatement(c *IterateStatementContext) + + // EnterLeaveStatement is called when entering the leaveStatement production. + EnterLeaveStatement(c *LeaveStatementContext) + + // EnterLoopStatement is called when entering the loopStatement production. + EnterLoopStatement(c *LoopStatementContext) + + // EnterRepeatStatement is called when entering the repeatStatement production. + EnterRepeatStatement(c *RepeatStatementContext) + + // EnterReturnStatement is called when entering the returnStatement production. + EnterReturnStatement(c *ReturnStatementContext) + + // EnterWhileStatement is called when entering the whileStatement production. + EnterWhileStatement(c *WhileStatementContext) + + // EnterCloseCursor is called when entering the CloseCursor production. + EnterCloseCursor(c *CloseCursorContext) + + // EnterFetchCursor is called when entering the FetchCursor production. + EnterFetchCursor(c *FetchCursorContext) + + // EnterOpenCursor is called when entering the OpenCursor production. + EnterOpenCursor(c *OpenCursorContext) + + // EnterDeclareVariable is called when entering the declareVariable production. + EnterDeclareVariable(c *DeclareVariableContext) + + // EnterDeclareCondition is called when entering the declareCondition production. + EnterDeclareCondition(c *DeclareConditionContext) + + // EnterDeclareCursor is called when entering the declareCursor production. + EnterDeclareCursor(c *DeclareCursorContext) + + // EnterDeclareHandler is called when entering the declareHandler production. + EnterDeclareHandler(c *DeclareHandlerContext) + + // EnterHandlerConditionCode is called when entering the handlerConditionCode production. + EnterHandlerConditionCode(c *HandlerConditionCodeContext) + + // EnterHandlerConditionState is called when entering the handlerConditionState production. + EnterHandlerConditionState(c *HandlerConditionStateContext) + + // EnterHandlerConditionName is called when entering the handlerConditionName production. + EnterHandlerConditionName(c *HandlerConditionNameContext) + + // EnterHandlerConditionWarning is called when entering the handlerConditionWarning production. + EnterHandlerConditionWarning(c *HandlerConditionWarningContext) + + // EnterHandlerConditionNotfound is called when entering the handlerConditionNotfound production. + EnterHandlerConditionNotfound(c *HandlerConditionNotfoundContext) + + // EnterHandlerConditionException is called when entering the handlerConditionException production. + EnterHandlerConditionException(c *HandlerConditionExceptionContext) + + // EnterProcedureSqlStatement is called when entering the procedureSqlStatement production. + EnterProcedureSqlStatement(c *ProcedureSqlStatementContext) + + // EnterCaseAlternative is called when entering the caseAlternative production. + EnterCaseAlternative(c *CaseAlternativeContext) + + // EnterElifAlternative is called when entering the elifAlternative production. + EnterElifAlternative(c *ElifAlternativeContext) + + // EnterAlterUserMysqlV56 is called when entering the alterUserMysqlV56 production. + EnterAlterUserMysqlV56(c *AlterUserMysqlV56Context) + + // EnterAlterUserMysqlV80 is called when entering the alterUserMysqlV80 production. + EnterAlterUserMysqlV80(c *AlterUserMysqlV80Context) + + // EnterCreateUserMysqlV56 is called when entering the createUserMysqlV56 production. + EnterCreateUserMysqlV56(c *CreateUserMysqlV56Context) + + // EnterCreateUserMysqlV80 is called when entering the createUserMysqlV80 production. + EnterCreateUserMysqlV80(c *CreateUserMysqlV80Context) + + // EnterDropUser is called when entering the dropUser production. + EnterDropUser(c *DropUserContext) + + // EnterGrantStatement is called when entering the grantStatement production. + EnterGrantStatement(c *GrantStatementContext) + + // EnterRoleOption is called when entering the roleOption production. + EnterRoleOption(c *RoleOptionContext) + + // EnterGrantProxy is called when entering the grantProxy production. + EnterGrantProxy(c *GrantProxyContext) + + // EnterRenameUser is called when entering the renameUser production. + EnterRenameUser(c *RenameUserContext) + + // EnterDetailRevoke is called when entering the detailRevoke production. + EnterDetailRevoke(c *DetailRevokeContext) + + // EnterShortRevoke is called when entering the shortRevoke production. + EnterShortRevoke(c *ShortRevokeContext) + + // EnterRoleRevoke is called when entering the roleRevoke production. + EnterRoleRevoke(c *RoleRevokeContext) + + // EnterRevokeProxy is called when entering the revokeProxy production. + EnterRevokeProxy(c *RevokeProxyContext) + + // EnterSetPasswordStatement is called when entering the setPasswordStatement production. + EnterSetPasswordStatement(c *SetPasswordStatementContext) + + // EnterUserSpecification is called when entering the userSpecification production. + EnterUserSpecification(c *UserSpecificationContext) + + // EnterHashAuthOption is called when entering the hashAuthOption production. + EnterHashAuthOption(c *HashAuthOptionContext) + + // EnterRandomAuthOption is called when entering the randomAuthOption production. + EnterRandomAuthOption(c *RandomAuthOptionContext) + + // EnterStringAuthOption is called when entering the stringAuthOption production. + EnterStringAuthOption(c *StringAuthOptionContext) + + // EnterModuleAuthOption is called when entering the moduleAuthOption production. + EnterModuleAuthOption(c *ModuleAuthOptionContext) + + // EnterSimpleAuthOption is called when entering the simpleAuthOption production. + EnterSimpleAuthOption(c *SimpleAuthOptionContext) + + // EnterAuthOptionClause is called when entering the authOptionClause production. + EnterAuthOptionClause(c *AuthOptionClauseContext) + + // EnterModule is called when entering the module production. + EnterModule(c *ModuleContext) + + // EnterPasswordModuleOption is called when entering the passwordModuleOption production. + EnterPasswordModuleOption(c *PasswordModuleOptionContext) + + // EnterTlsOption is called when entering the tlsOption production. + EnterTlsOption(c *TlsOptionContext) + + // EnterUserResourceOption is called when entering the userResourceOption production. + EnterUserResourceOption(c *UserResourceOptionContext) + + // EnterUserPasswordOption is called when entering the userPasswordOption production. + EnterUserPasswordOption(c *UserPasswordOptionContext) + + // EnterUserLockOption is called when entering the userLockOption production. + EnterUserLockOption(c *UserLockOptionContext) + + // EnterPrivelegeClause is called when entering the privelegeClause production. + EnterPrivelegeClause(c *PrivelegeClauseContext) + + // EnterPrivilege is called when entering the privilege production. + EnterPrivilege(c *PrivilegeContext) + + // EnterCurrentSchemaPriviLevel is called when entering the currentSchemaPriviLevel production. + EnterCurrentSchemaPriviLevel(c *CurrentSchemaPriviLevelContext) + + // EnterGlobalPrivLevel is called when entering the globalPrivLevel production. + EnterGlobalPrivLevel(c *GlobalPrivLevelContext) + + // EnterDefiniteSchemaPrivLevel is called when entering the definiteSchemaPrivLevel production. + EnterDefiniteSchemaPrivLevel(c *DefiniteSchemaPrivLevelContext) + + // EnterDefiniteFullTablePrivLevel is called when entering the definiteFullTablePrivLevel production. + EnterDefiniteFullTablePrivLevel(c *DefiniteFullTablePrivLevelContext) + + // EnterDefiniteFullTablePrivLevel2 is called when entering the definiteFullTablePrivLevel2 production. + EnterDefiniteFullTablePrivLevel2(c *DefiniteFullTablePrivLevel2Context) + + // EnterDefiniteTablePrivLevel is called when entering the definiteTablePrivLevel production. + EnterDefiniteTablePrivLevel(c *DefiniteTablePrivLevelContext) + + // EnterRenameUserClause is called when entering the renameUserClause production. + EnterRenameUserClause(c *RenameUserClauseContext) + + // EnterAnalyzeTable is called when entering the analyzeTable production. + EnterAnalyzeTable(c *AnalyzeTableContext) + + // EnterCheckTable is called when entering the checkTable production. + EnterCheckTable(c *CheckTableContext) + + // EnterChecksumTable is called when entering the checksumTable production. + EnterChecksumTable(c *ChecksumTableContext) + + // EnterOptimizeTable is called when entering the optimizeTable production. + EnterOptimizeTable(c *OptimizeTableContext) + + // EnterRepairTable is called when entering the repairTable production. + EnterRepairTable(c *RepairTableContext) + + // EnterCheckTableOption is called when entering the checkTableOption production. + EnterCheckTableOption(c *CheckTableOptionContext) + + // EnterCreateUdfunction is called when entering the createUdfunction production. + EnterCreateUdfunction(c *CreateUdfunctionContext) + + // EnterInstallPlugin is called when entering the installPlugin production. + EnterInstallPlugin(c *InstallPluginContext) + + // EnterUninstallPlugin is called when entering the uninstallPlugin production. + EnterUninstallPlugin(c *UninstallPluginContext) + + // EnterSetVariable is called when entering the setVariable production. + EnterSetVariable(c *SetVariableContext) + + // EnterSetCharset is called when entering the setCharset production. + EnterSetCharset(c *SetCharsetContext) + + // EnterSetNames is called when entering the setNames production. + EnterSetNames(c *SetNamesContext) + + // EnterSetPassword is called when entering the setPassword production. + EnterSetPassword(c *SetPasswordContext) + + // EnterSetTransaction is called when entering the setTransaction production. + EnterSetTransaction(c *SetTransactionContext) + + // EnterSetAutocommit is called when entering the setAutocommit production. + EnterSetAutocommit(c *SetAutocommitContext) + + // EnterSetNewValueInsideTrigger is called when entering the setNewValueInsideTrigger production. + EnterSetNewValueInsideTrigger(c *SetNewValueInsideTriggerContext) + + // EnterShowMasterLogs is called when entering the showMasterLogs production. + EnterShowMasterLogs(c *ShowMasterLogsContext) + + // EnterShowLogEvents is called when entering the showLogEvents production. + EnterShowLogEvents(c *ShowLogEventsContext) + + // EnterShowObjectFilter is called when entering the showObjectFilter production. + EnterShowObjectFilter(c *ShowObjectFilterContext) + + // EnterShowColumns is called when entering the showColumns production. + EnterShowColumns(c *ShowColumnsContext) + + // EnterShowCreateDb is called when entering the showCreateDb production. + EnterShowCreateDb(c *ShowCreateDbContext) + + // EnterShowCreateFullIdObject is called when entering the showCreateFullIdObject production. + EnterShowCreateFullIdObject(c *ShowCreateFullIdObjectContext) + + // EnterShowCreateUser is called when entering the showCreateUser production. + EnterShowCreateUser(c *ShowCreateUserContext) + + // EnterShowEngine is called when entering the showEngine production. + EnterShowEngine(c *ShowEngineContext) + + // EnterShowGlobalInfo is called when entering the showGlobalInfo production. + EnterShowGlobalInfo(c *ShowGlobalInfoContext) + + // EnterShowErrors is called when entering the showErrors production. + EnterShowErrors(c *ShowErrorsContext) + + // EnterShowCountErrors is called when entering the showCountErrors production. + EnterShowCountErrors(c *ShowCountErrorsContext) + + // EnterShowSchemaFilter is called when entering the showSchemaFilter production. + EnterShowSchemaFilter(c *ShowSchemaFilterContext) + + // EnterShowRoutine is called when entering the showRoutine production. + EnterShowRoutine(c *ShowRoutineContext) + + // EnterShowGrants is called when entering the showGrants production. + EnterShowGrants(c *ShowGrantsContext) + + // EnterShowIndexes is called when entering the showIndexes production. + EnterShowIndexes(c *ShowIndexesContext) + + // EnterShowOpenTables is called when entering the showOpenTables production. + EnterShowOpenTables(c *ShowOpenTablesContext) + + // EnterShowProfile is called when entering the showProfile production. + EnterShowProfile(c *ShowProfileContext) + + // EnterShowSlaveStatus is called when entering the showSlaveStatus production. + EnterShowSlaveStatus(c *ShowSlaveStatusContext) + + // EnterVariableClause is called when entering the variableClause production. + EnterVariableClause(c *VariableClauseContext) + + // EnterShowCommonEntity is called when entering the showCommonEntity production. + EnterShowCommonEntity(c *ShowCommonEntityContext) + + // EnterShowFilter is called when entering the showFilter production. + EnterShowFilter(c *ShowFilterContext) + + // EnterShowGlobalInfoClause is called when entering the showGlobalInfoClause production. + EnterShowGlobalInfoClause(c *ShowGlobalInfoClauseContext) + + // EnterShowSchemaEntity is called when entering the showSchemaEntity production. + EnterShowSchemaEntity(c *ShowSchemaEntityContext) + + // EnterShowProfileType is called when entering the showProfileType production. + EnterShowProfileType(c *ShowProfileTypeContext) + + // EnterBinlogStatement is called when entering the binlogStatement production. + EnterBinlogStatement(c *BinlogStatementContext) + + // EnterCacheIndexStatement is called when entering the cacheIndexStatement production. + EnterCacheIndexStatement(c *CacheIndexStatementContext) + + // EnterFlushStatement is called when entering the flushStatement production. + EnterFlushStatement(c *FlushStatementContext) + + // EnterKillStatement is called when entering the killStatement production. + EnterKillStatement(c *KillStatementContext) + + // EnterLoadIndexIntoCache is called when entering the loadIndexIntoCache production. + EnterLoadIndexIntoCache(c *LoadIndexIntoCacheContext) + + // EnterResetStatement is called when entering the resetStatement production. + EnterResetStatement(c *ResetStatementContext) + + // EnterShutdownStatement is called when entering the shutdownStatement production. + EnterShutdownStatement(c *ShutdownStatementContext) + + // EnterTableIndexes is called when entering the tableIndexes production. + EnterTableIndexes(c *TableIndexesContext) + + // EnterSimpleFlushOption is called when entering the simpleFlushOption production. + EnterSimpleFlushOption(c *SimpleFlushOptionContext) + + // EnterChannelFlushOption is called when entering the channelFlushOption production. + EnterChannelFlushOption(c *ChannelFlushOptionContext) + + // EnterTableFlushOption is called when entering the tableFlushOption production. + EnterTableFlushOption(c *TableFlushOptionContext) + + // EnterFlushTableOption is called when entering the flushTableOption production. + EnterFlushTableOption(c *FlushTableOptionContext) + + // EnterLoadedTableIndexes is called when entering the loadedTableIndexes production. + EnterLoadedTableIndexes(c *LoadedTableIndexesContext) + + // EnterSimpleDescribeStatement is called when entering the simpleDescribeStatement production. + EnterSimpleDescribeStatement(c *SimpleDescribeStatementContext) + + // EnterFullDescribeStatement is called when entering the fullDescribeStatement production. + EnterFullDescribeStatement(c *FullDescribeStatementContext) + + // EnterHelpStatement is called when entering the helpStatement production. + EnterHelpStatement(c *HelpStatementContext) + + // EnterUseStatement is called when entering the useStatement production. + EnterUseStatement(c *UseStatementContext) + + // EnterSignalStatement is called when entering the signalStatement production. + EnterSignalStatement(c *SignalStatementContext) + + // EnterResignalStatement is called when entering the resignalStatement production. + EnterResignalStatement(c *ResignalStatementContext) + + // EnterSignalConditionInformation is called when entering the signalConditionInformation production. + EnterSignalConditionInformation(c *SignalConditionInformationContext) + + // EnterWithStatement is called when entering the withStatement production. + EnterWithStatement(c *WithStatementContext) + + // EnterTableStatement is called when entering the tableStatement production. + EnterTableStatement(c *TableStatementContext) + + // EnterDiagnosticsStatement is called when entering the diagnosticsStatement production. + EnterDiagnosticsStatement(c *DiagnosticsStatementContext) + + // EnterDiagnosticsConditionInformationName is called when entering the diagnosticsConditionInformationName production. + EnterDiagnosticsConditionInformationName(c *DiagnosticsConditionInformationNameContext) + + // EnterDescribeStatements is called when entering the describeStatements production. + EnterDescribeStatements(c *DescribeStatementsContext) + + // EnterDescribeConnection is called when entering the describeConnection production. + EnterDescribeConnection(c *DescribeConnectionContext) + + // EnterFullId is called when entering the fullId production. + EnterFullId(c *FullIdContext) + + // EnterTableName is called when entering the tableName production. + EnterTableName(c *TableNameContext) + + // EnterRoleName is called when entering the roleName production. + EnterRoleName(c *RoleNameContext) + + // EnterFullColumnName is called when entering the fullColumnName production. + EnterFullColumnName(c *FullColumnNameContext) + + // EnterIndexColumnName is called when entering the indexColumnName production. + EnterIndexColumnName(c *IndexColumnNameContext) + + // EnterSimpleUserName is called when entering the simpleUserName production. + EnterSimpleUserName(c *SimpleUserNameContext) + + // EnterHostName is called when entering the hostName production. + EnterHostName(c *HostNameContext) + + // EnterUserName is called when entering the userName production. + EnterUserName(c *UserNameContext) + + // EnterMysqlVariable is called when entering the mysqlVariable production. + EnterMysqlVariable(c *MysqlVariableContext) + + // EnterCharsetName is called when entering the charsetName production. + EnterCharsetName(c *CharsetNameContext) + + // EnterCollationName is called when entering the collationName production. + EnterCollationName(c *CollationNameContext) + + // EnterEngineName is called when entering the engineName production. + EnterEngineName(c *EngineNameContext) + + // EnterEngineNameBase is called when entering the engineNameBase production. + EnterEngineNameBase(c *EngineNameBaseContext) + + // EnterUuidSet is called when entering the uuidSet production. + EnterUuidSet(c *UuidSetContext) + + // EnterXid is called when entering the xid production. + EnterXid(c *XidContext) + + // EnterXuidStringId is called when entering the xuidStringId production. + EnterXuidStringId(c *XuidStringIdContext) + + // EnterAuthPlugin is called when entering the authPlugin production. + EnterAuthPlugin(c *AuthPluginContext) + + // EnterUid is called when entering the uid production. + EnterUid(c *UidContext) + + // EnterSimpleId is called when entering the simpleId production. + EnterSimpleId(c *SimpleIdContext) + + // EnterDottedId is called when entering the dottedId production. + EnterDottedId(c *DottedIdContext) + + // EnterDecimalLiteral is called when entering the decimalLiteral production. + EnterDecimalLiteral(c *DecimalLiteralContext) + + // EnterFileSizeLiteral is called when entering the fileSizeLiteral production. + EnterFileSizeLiteral(c *FileSizeLiteralContext) + + // EnterStringLiteral is called when entering the stringLiteral production. + EnterStringLiteral(c *StringLiteralContext) + + // EnterBooleanLiteral is called when entering the booleanLiteral production. + EnterBooleanLiteral(c *BooleanLiteralContext) + + // EnterHexadecimalLiteral is called when entering the hexadecimalLiteral production. + EnterHexadecimalLiteral(c *HexadecimalLiteralContext) + + // EnterNullNotnull is called when entering the nullNotnull production. + EnterNullNotnull(c *NullNotnullContext) + + // EnterConstant is called when entering the constant production. + EnterConstant(c *ConstantContext) + + // EnterStringDataType is called when entering the stringDataType production. + EnterStringDataType(c *StringDataTypeContext) + + // EnterNationalVaryingStringDataType is called when entering the nationalVaryingStringDataType production. + EnterNationalVaryingStringDataType(c *NationalVaryingStringDataTypeContext) + + // EnterNationalStringDataType is called when entering the nationalStringDataType production. + EnterNationalStringDataType(c *NationalStringDataTypeContext) + + // EnterDimensionDataType is called when entering the dimensionDataType production. + EnterDimensionDataType(c *DimensionDataTypeContext) + + // EnterSimpleDataType is called when entering the simpleDataType production. + EnterSimpleDataType(c *SimpleDataTypeContext) + + // EnterCollectionDataType is called when entering the collectionDataType production. + EnterCollectionDataType(c *CollectionDataTypeContext) + + // EnterSpatialDataType is called when entering the spatialDataType production. + EnterSpatialDataType(c *SpatialDataTypeContext) + + // EnterLongVarcharDataType is called when entering the longVarcharDataType production. + EnterLongVarcharDataType(c *LongVarcharDataTypeContext) + + // EnterLongVarbinaryDataType is called when entering the longVarbinaryDataType production. + EnterLongVarbinaryDataType(c *LongVarbinaryDataTypeContext) + + // EnterCollectionOptions is called when entering the collectionOptions production. + EnterCollectionOptions(c *CollectionOptionsContext) + + // EnterConvertedDataType is called when entering the convertedDataType production. + EnterConvertedDataType(c *ConvertedDataTypeContext) + + // EnterLengthOneDimension is called when entering the lengthOneDimension production. + EnterLengthOneDimension(c *LengthOneDimensionContext) + + // EnterLengthTwoDimension is called when entering the lengthTwoDimension production. + EnterLengthTwoDimension(c *LengthTwoDimensionContext) + + // EnterLengthTwoOptionalDimension is called when entering the lengthTwoOptionalDimension production. + EnterLengthTwoOptionalDimension(c *LengthTwoOptionalDimensionContext) + + // EnterUidList is called when entering the uidList production. + EnterUidList(c *UidListContext) + + // EnterFullColumnNameList is called when entering the fullColumnNameList production. + EnterFullColumnNameList(c *FullColumnNameListContext) + + // EnterTables is called when entering the tables production. + EnterTables(c *TablesContext) + + // EnterIndexColumnNames is called when entering the indexColumnNames production. + EnterIndexColumnNames(c *IndexColumnNamesContext) + + // EnterExpressions is called when entering the expressions production. + EnterExpressions(c *ExpressionsContext) + + // EnterExpressionsWithDefaults is called when entering the expressionsWithDefaults production. + EnterExpressionsWithDefaults(c *ExpressionsWithDefaultsContext) + + // EnterConstants is called when entering the constants production. + EnterConstants(c *ConstantsContext) + + // EnterSimpleStrings is called when entering the simpleStrings production. + EnterSimpleStrings(c *SimpleStringsContext) + + // EnterUserVariables is called when entering the userVariables production. + EnterUserVariables(c *UserVariablesContext) + + // EnterDefaultValue is called when entering the defaultValue production. + EnterDefaultValue(c *DefaultValueContext) + + // EnterCurrentTimestamp is called when entering the currentTimestamp production. + EnterCurrentTimestamp(c *CurrentTimestampContext) + + // EnterExpressionOrDefault is called when entering the expressionOrDefault production. + EnterExpressionOrDefault(c *ExpressionOrDefaultContext) + + // EnterIfExists is called when entering the ifExists production. + EnterIfExists(c *IfExistsContext) + + // EnterIfNotExists is called when entering the ifNotExists production. + EnterIfNotExists(c *IfNotExistsContext) + + // EnterOrReplace is called when entering the orReplace production. + EnterOrReplace(c *OrReplaceContext) + + // EnterWaitNowaitClause is called when entering the waitNowaitClause production. + EnterWaitNowaitClause(c *WaitNowaitClauseContext) + + // EnterSpecificFunctionCall is called when entering the specificFunctionCall production. + EnterSpecificFunctionCall(c *SpecificFunctionCallContext) + + // EnterAggregateFunctionCall is called when entering the aggregateFunctionCall production. + EnterAggregateFunctionCall(c *AggregateFunctionCallContext) + + // EnterNonAggregateFunctionCall is called when entering the nonAggregateFunctionCall production. + EnterNonAggregateFunctionCall(c *NonAggregateFunctionCallContext) + + // EnterScalarFunctionCall is called when entering the scalarFunctionCall production. + EnterScalarFunctionCall(c *ScalarFunctionCallContext) + + // EnterUdfFunctionCall is called when entering the udfFunctionCall production. + EnterUdfFunctionCall(c *UdfFunctionCallContext) + + // EnterPasswordFunctionCall is called when entering the passwordFunctionCall production. + EnterPasswordFunctionCall(c *PasswordFunctionCallContext) + + // EnterSimpleFunctionCall is called when entering the simpleFunctionCall production. + EnterSimpleFunctionCall(c *SimpleFunctionCallContext) + + // EnterCurrentUser is called when entering the currentUser production. + EnterCurrentUser(c *CurrentUserContext) + + // EnterDataTypeFunctionCall is called when entering the dataTypeFunctionCall production. + EnterDataTypeFunctionCall(c *DataTypeFunctionCallContext) + + // EnterValuesFunctionCall is called when entering the valuesFunctionCall production. + EnterValuesFunctionCall(c *ValuesFunctionCallContext) + + // EnterCaseExpressionFunctionCall is called when entering the caseExpressionFunctionCall production. + EnterCaseExpressionFunctionCall(c *CaseExpressionFunctionCallContext) + + // EnterCaseFunctionCall is called when entering the caseFunctionCall production. + EnterCaseFunctionCall(c *CaseFunctionCallContext) + + // EnterCharFunctionCall is called when entering the charFunctionCall production. + EnterCharFunctionCall(c *CharFunctionCallContext) + + // EnterPositionFunctionCall is called when entering the positionFunctionCall production. + EnterPositionFunctionCall(c *PositionFunctionCallContext) + + // EnterSubstrFunctionCall is called when entering the substrFunctionCall production. + EnterSubstrFunctionCall(c *SubstrFunctionCallContext) + + // EnterTrimFunctionCall is called when entering the trimFunctionCall production. + EnterTrimFunctionCall(c *TrimFunctionCallContext) + + // EnterWeightFunctionCall is called when entering the weightFunctionCall production. + EnterWeightFunctionCall(c *WeightFunctionCallContext) + + // EnterExtractFunctionCall is called when entering the extractFunctionCall production. + EnterExtractFunctionCall(c *ExtractFunctionCallContext) + + // EnterGetFormatFunctionCall is called when entering the getFormatFunctionCall production. + EnterGetFormatFunctionCall(c *GetFormatFunctionCallContext) + + // EnterJsonValueFunctionCall is called when entering the jsonValueFunctionCall production. + EnterJsonValueFunctionCall(c *JsonValueFunctionCallContext) + + // EnterCaseFuncAlternative is called when entering the caseFuncAlternative production. + EnterCaseFuncAlternative(c *CaseFuncAlternativeContext) + + // EnterLevelWeightList is called when entering the levelWeightList production. + EnterLevelWeightList(c *LevelWeightListContext) + + // EnterLevelWeightRange is called when entering the levelWeightRange production. + EnterLevelWeightRange(c *LevelWeightRangeContext) + + // EnterLevelInWeightListElement is called when entering the levelInWeightListElement production. + EnterLevelInWeightListElement(c *LevelInWeightListElementContext) + + // EnterAggregateWindowedFunction is called when entering the aggregateWindowedFunction production. + EnterAggregateWindowedFunction(c *AggregateWindowedFunctionContext) + + // EnterNonAggregateWindowedFunction is called when entering the nonAggregateWindowedFunction production. + EnterNonAggregateWindowedFunction(c *NonAggregateWindowedFunctionContext) + + // EnterOverClause is called when entering the overClause production. + EnterOverClause(c *OverClauseContext) + + // EnterWindowSpec is called when entering the windowSpec production. + EnterWindowSpec(c *WindowSpecContext) + + // EnterWindowName is called when entering the windowName production. + EnterWindowName(c *WindowNameContext) + + // EnterFrameClause is called when entering the frameClause production. + EnterFrameClause(c *FrameClauseContext) + + // EnterFrameUnits is called when entering the frameUnits production. + EnterFrameUnits(c *FrameUnitsContext) + + // EnterFrameExtent is called when entering the frameExtent production. + EnterFrameExtent(c *FrameExtentContext) + + // EnterFrameBetween is called when entering the frameBetween production. + EnterFrameBetween(c *FrameBetweenContext) + + // EnterFrameRange is called when entering the frameRange production. + EnterFrameRange(c *FrameRangeContext) + + // EnterPartitionClause is called when entering the partitionClause production. + EnterPartitionClause(c *PartitionClauseContext) + + // EnterScalarFunctionName is called when entering the scalarFunctionName production. + EnterScalarFunctionName(c *ScalarFunctionNameContext) + + // EnterPasswordFunctionClause is called when entering the passwordFunctionClause production. + EnterPasswordFunctionClause(c *PasswordFunctionClauseContext) + + // EnterFunctionArgs is called when entering the functionArgs production. + EnterFunctionArgs(c *FunctionArgsContext) + + // EnterFunctionArg is called when entering the functionArg production. + EnterFunctionArg(c *FunctionArgContext) + + // EnterIsExpression is called when entering the isExpression production. + EnterIsExpression(c *IsExpressionContext) + + // EnterNotExpression is called when entering the notExpression production. + EnterNotExpression(c *NotExpressionContext) + + // EnterLogicalExpression is called when entering the logicalExpression production. + EnterLogicalExpression(c *LogicalExpressionContext) + + // EnterPredicateExpression is called when entering the predicateExpression production. + EnterPredicateExpression(c *PredicateExpressionContext) + + // EnterSoundsLikePredicate is called when entering the soundsLikePredicate production. + EnterSoundsLikePredicate(c *SoundsLikePredicateContext) + + // EnterExpressionAtomPredicate is called when entering the expressionAtomPredicate production. + EnterExpressionAtomPredicate(c *ExpressionAtomPredicateContext) + + // EnterSubqueryComparisonPredicate is called when entering the subqueryComparisonPredicate production. + EnterSubqueryComparisonPredicate(c *SubqueryComparisonPredicateContext) + + // EnterJsonMemberOfPredicate is called when entering the jsonMemberOfPredicate production. + EnterJsonMemberOfPredicate(c *JsonMemberOfPredicateContext) + + // EnterBinaryComparisonPredicate is called when entering the binaryComparisonPredicate production. + EnterBinaryComparisonPredicate(c *BinaryComparisonPredicateContext) + + // EnterInPredicate is called when entering the inPredicate production. + EnterInPredicate(c *InPredicateContext) + + // EnterBetweenPredicate is called when entering the betweenPredicate production. + EnterBetweenPredicate(c *BetweenPredicateContext) + + // EnterIsNullPredicate is called when entering the isNullPredicate production. + EnterIsNullPredicate(c *IsNullPredicateContext) + + // EnterLikePredicate is called when entering the likePredicate production. + EnterLikePredicate(c *LikePredicateContext) + + // EnterRegexpPredicate is called when entering the regexpPredicate production. + EnterRegexpPredicate(c *RegexpPredicateContext) + + // EnterUnaryExpressionAtom is called when entering the unaryExpressionAtom production. + EnterUnaryExpressionAtom(c *UnaryExpressionAtomContext) + + // EnterCollateExpressionAtom is called when entering the collateExpressionAtom production. + EnterCollateExpressionAtom(c *CollateExpressionAtomContext) + + // EnterVariableAssignExpressionAtom is called when entering the variableAssignExpressionAtom production. + EnterVariableAssignExpressionAtom(c *VariableAssignExpressionAtomContext) + + // EnterMysqlVariableExpressionAtom is called when entering the mysqlVariableExpressionAtom production. + EnterMysqlVariableExpressionAtom(c *MysqlVariableExpressionAtomContext) + + // EnterNestedExpressionAtom is called when entering the nestedExpressionAtom production. + EnterNestedExpressionAtom(c *NestedExpressionAtomContext) + + // EnterNestedRowExpressionAtom is called when entering the nestedRowExpressionAtom production. + EnterNestedRowExpressionAtom(c *NestedRowExpressionAtomContext) + + // EnterMathExpressionAtom is called when entering the mathExpressionAtom production. + EnterMathExpressionAtom(c *MathExpressionAtomContext) + + // EnterExistsExpressionAtom is called when entering the existsExpressionAtom production. + EnterExistsExpressionAtom(c *ExistsExpressionAtomContext) + + // EnterIntervalExpressionAtom is called when entering the intervalExpressionAtom production. + EnterIntervalExpressionAtom(c *IntervalExpressionAtomContext) + + // EnterJsonExpressionAtom is called when entering the jsonExpressionAtom production. + EnterJsonExpressionAtom(c *JsonExpressionAtomContext) + + // EnterSubqueryExpressionAtom is called when entering the subqueryExpressionAtom production. + EnterSubqueryExpressionAtom(c *SubqueryExpressionAtomContext) + + // EnterConstantExpressionAtom is called when entering the constantExpressionAtom production. + EnterConstantExpressionAtom(c *ConstantExpressionAtomContext) + + // EnterFunctionCallExpressionAtom is called when entering the functionCallExpressionAtom production. + EnterFunctionCallExpressionAtom(c *FunctionCallExpressionAtomContext) + + // EnterBinaryExpressionAtom is called when entering the binaryExpressionAtom production. + EnterBinaryExpressionAtom(c *BinaryExpressionAtomContext) + + // EnterFullColumnNameExpressionAtom is called when entering the fullColumnNameExpressionAtom production. + EnterFullColumnNameExpressionAtom(c *FullColumnNameExpressionAtomContext) + + // EnterBitExpressionAtom is called when entering the bitExpressionAtom production. + EnterBitExpressionAtom(c *BitExpressionAtomContext) + + // EnterUnaryOperator is called when entering the unaryOperator production. + EnterUnaryOperator(c *UnaryOperatorContext) + + // EnterComparisonOperator is called when entering the comparisonOperator production. + EnterComparisonOperator(c *ComparisonOperatorContext) + + // EnterLogicalOperator is called when entering the logicalOperator production. + EnterLogicalOperator(c *LogicalOperatorContext) + + // EnterBitOperator is called when entering the bitOperator production. + EnterBitOperator(c *BitOperatorContext) + + // EnterMultOperator is called when entering the multOperator production. + EnterMultOperator(c *MultOperatorContext) + + // EnterAddOperator is called when entering the addOperator production. + EnterAddOperator(c *AddOperatorContext) + + // EnterJsonOperator is called when entering the jsonOperator production. + EnterJsonOperator(c *JsonOperatorContext) + + // EnterCharsetNameBase is called when entering the charsetNameBase production. + EnterCharsetNameBase(c *CharsetNameBaseContext) + + // EnterTransactionLevelBase is called when entering the transactionLevelBase production. + EnterTransactionLevelBase(c *TransactionLevelBaseContext) + + // EnterPrivilegesBase is called when entering the privilegesBase production. + EnterPrivilegesBase(c *PrivilegesBaseContext) + + // EnterIntervalTypeBase is called when entering the intervalTypeBase production. + EnterIntervalTypeBase(c *IntervalTypeBaseContext) + + // EnterDataTypeBase is called when entering the dataTypeBase production. + EnterDataTypeBase(c *DataTypeBaseContext) + + // EnterKeywordsCanBeId is called when entering the keywordsCanBeId production. + EnterKeywordsCanBeId(c *KeywordsCanBeIdContext) + + // EnterFunctionNameBase is called when entering the functionNameBase production. + EnterFunctionNameBase(c *FunctionNameBaseContext) + + // ExitRoot is called when exiting the root production. + ExitRoot(c *RootContext) + + // ExitSqlStatements is called when exiting the sqlStatements production. + ExitSqlStatements(c *SqlStatementsContext) + + // ExitSqlStatement is called when exiting the sqlStatement production. + ExitSqlStatement(c *SqlStatementContext) + + // ExitEmptyStatement_ is called when exiting the emptyStatement_ production. + ExitEmptyStatement_(c *EmptyStatement_Context) + + // ExitDdlStatement is called when exiting the ddlStatement production. + ExitDdlStatement(c *DdlStatementContext) + + // ExitDmlStatement is called when exiting the dmlStatement production. + ExitDmlStatement(c *DmlStatementContext) + + // ExitTransactionStatement is called when exiting the transactionStatement production. + ExitTransactionStatement(c *TransactionStatementContext) + + // ExitReplicationStatement is called when exiting the replicationStatement production. + ExitReplicationStatement(c *ReplicationStatementContext) + + // ExitPreparedStatement is called when exiting the preparedStatement production. + ExitPreparedStatement(c *PreparedStatementContext) + + // ExitCompoundStatement is called when exiting the compoundStatement production. + ExitCompoundStatement(c *CompoundStatementContext) + + // ExitAdministrationStatement is called when exiting the administrationStatement production. + ExitAdministrationStatement(c *AdministrationStatementContext) + + // ExitUtilityStatement is called when exiting the utilityStatement production. + ExitUtilityStatement(c *UtilityStatementContext) + + // ExitCreateDatabase is called when exiting the createDatabase production. + ExitCreateDatabase(c *CreateDatabaseContext) + + // ExitCreateEvent is called when exiting the createEvent production. + ExitCreateEvent(c *CreateEventContext) + + // ExitCreateIndex is called when exiting the createIndex production. + ExitCreateIndex(c *CreateIndexContext) + + // ExitCreateLogfileGroup is called when exiting the createLogfileGroup production. + ExitCreateLogfileGroup(c *CreateLogfileGroupContext) + + // ExitCreateProcedure is called when exiting the createProcedure production. + ExitCreateProcedure(c *CreateProcedureContext) + + // ExitCreateFunction is called when exiting the createFunction production. + ExitCreateFunction(c *CreateFunctionContext) + + // ExitCreateRole is called when exiting the createRole production. + ExitCreateRole(c *CreateRoleContext) + + // ExitCreateServer is called when exiting the createServer production. + ExitCreateServer(c *CreateServerContext) + + // ExitCopyCreateTable is called when exiting the copyCreateTable production. + ExitCopyCreateTable(c *CopyCreateTableContext) + + // ExitQueryCreateTable is called when exiting the queryCreateTable production. + ExitQueryCreateTable(c *QueryCreateTableContext) + + // ExitColumnCreateTable is called when exiting the columnCreateTable production. + ExitColumnCreateTable(c *ColumnCreateTableContext) + + // ExitCreateTablespaceInnodb is called when exiting the createTablespaceInnodb production. + ExitCreateTablespaceInnodb(c *CreateTablespaceInnodbContext) + + // ExitCreateTablespaceNdb is called when exiting the createTablespaceNdb production. + ExitCreateTablespaceNdb(c *CreateTablespaceNdbContext) + + // ExitCreateTrigger is called when exiting the createTrigger production. + ExitCreateTrigger(c *CreateTriggerContext) + + // ExitWithClause is called when exiting the withClause production. + ExitWithClause(c *WithClauseContext) + + // ExitCommonTableExpressions is called when exiting the commonTableExpressions production. + ExitCommonTableExpressions(c *CommonTableExpressionsContext) + + // ExitCteName is called when exiting the cteName production. + ExitCteName(c *CteNameContext) + + // ExitCteColumnName is called when exiting the cteColumnName production. + ExitCteColumnName(c *CteColumnNameContext) + + // ExitCreateView is called when exiting the createView production. + ExitCreateView(c *CreateViewContext) + + // ExitCreateDatabaseOption is called when exiting the createDatabaseOption production. + ExitCreateDatabaseOption(c *CreateDatabaseOptionContext) + + // ExitCharSet is called when exiting the charSet production. + ExitCharSet(c *CharSetContext) + + // ExitCurrentUserExpression is called when exiting the currentUserExpression production. + ExitCurrentUserExpression(c *CurrentUserExpressionContext) + + // ExitOwnerStatement is called when exiting the ownerStatement production. + ExitOwnerStatement(c *OwnerStatementContext) + + // ExitPreciseSchedule is called when exiting the preciseSchedule production. + ExitPreciseSchedule(c *PreciseScheduleContext) + + // ExitIntervalSchedule is called when exiting the intervalSchedule production. + ExitIntervalSchedule(c *IntervalScheduleContext) + + // ExitTimestampValue is called when exiting the timestampValue production. + ExitTimestampValue(c *TimestampValueContext) + + // ExitIntervalExpr is called when exiting the intervalExpr production. + ExitIntervalExpr(c *IntervalExprContext) + + // ExitIntervalType is called when exiting the intervalType production. + ExitIntervalType(c *IntervalTypeContext) + + // ExitEnableType is called when exiting the enableType production. + ExitEnableType(c *EnableTypeContext) + + // ExitIndexType is called when exiting the indexType production. + ExitIndexType(c *IndexTypeContext) + + // ExitIndexOption is called when exiting the indexOption production. + ExitIndexOption(c *IndexOptionContext) + + // ExitProcedureParameter is called when exiting the procedureParameter production. + ExitProcedureParameter(c *ProcedureParameterContext) + + // ExitFunctionParameter is called when exiting the functionParameter production. + ExitFunctionParameter(c *FunctionParameterContext) + + // ExitRoutineComment is called when exiting the routineComment production. + ExitRoutineComment(c *RoutineCommentContext) + + // ExitRoutineLanguage is called when exiting the routineLanguage production. + ExitRoutineLanguage(c *RoutineLanguageContext) + + // ExitRoutineBehavior is called when exiting the routineBehavior production. + ExitRoutineBehavior(c *RoutineBehaviorContext) + + // ExitRoutineData is called when exiting the routineData production. + ExitRoutineData(c *RoutineDataContext) + + // ExitRoutineSecurity is called when exiting the routineSecurity production. + ExitRoutineSecurity(c *RoutineSecurityContext) + + // ExitServerOption is called when exiting the serverOption production. + ExitServerOption(c *ServerOptionContext) + + // ExitCreateDefinitions is called when exiting the createDefinitions production. + ExitCreateDefinitions(c *CreateDefinitionsContext) + + // ExitColumnDeclaration is called when exiting the columnDeclaration production. + ExitColumnDeclaration(c *ColumnDeclarationContext) + + // ExitConstraintDeclaration is called when exiting the constraintDeclaration production. + ExitConstraintDeclaration(c *ConstraintDeclarationContext) + + // ExitIndexDeclaration is called when exiting the indexDeclaration production. + ExitIndexDeclaration(c *IndexDeclarationContext) + + // ExitColumnDefinition is called when exiting the columnDefinition production. + ExitColumnDefinition(c *ColumnDefinitionContext) + + // ExitNullColumnConstraint is called when exiting the nullColumnConstraint production. + ExitNullColumnConstraint(c *NullColumnConstraintContext) + + // ExitDefaultColumnConstraint is called when exiting the defaultColumnConstraint production. + ExitDefaultColumnConstraint(c *DefaultColumnConstraintContext) + + // ExitVisibilityColumnConstraint is called when exiting the visibilityColumnConstraint production. + ExitVisibilityColumnConstraint(c *VisibilityColumnConstraintContext) + + // ExitInvisibilityColumnConstraint is called when exiting the invisibilityColumnConstraint production. + ExitInvisibilityColumnConstraint(c *InvisibilityColumnConstraintContext) + + // ExitAutoIncrementColumnConstraint is called when exiting the autoIncrementColumnConstraint production. + ExitAutoIncrementColumnConstraint(c *AutoIncrementColumnConstraintContext) + + // ExitPrimaryKeyColumnConstraint is called when exiting the primaryKeyColumnConstraint production. + ExitPrimaryKeyColumnConstraint(c *PrimaryKeyColumnConstraintContext) + + // ExitUniqueKeyColumnConstraint is called when exiting the uniqueKeyColumnConstraint production. + ExitUniqueKeyColumnConstraint(c *UniqueKeyColumnConstraintContext) + + // ExitCommentColumnConstraint is called when exiting the commentColumnConstraint production. + ExitCommentColumnConstraint(c *CommentColumnConstraintContext) + + // ExitFormatColumnConstraint is called when exiting the formatColumnConstraint production. + ExitFormatColumnConstraint(c *FormatColumnConstraintContext) + + // ExitStorageColumnConstraint is called when exiting the storageColumnConstraint production. + ExitStorageColumnConstraint(c *StorageColumnConstraintContext) + + // ExitReferenceColumnConstraint is called when exiting the referenceColumnConstraint production. + ExitReferenceColumnConstraint(c *ReferenceColumnConstraintContext) + + // ExitCollateColumnConstraint is called when exiting the collateColumnConstraint production. + ExitCollateColumnConstraint(c *CollateColumnConstraintContext) + + // ExitGeneratedColumnConstraint is called when exiting the generatedColumnConstraint production. + ExitGeneratedColumnConstraint(c *GeneratedColumnConstraintContext) + + // ExitSerialDefaultColumnConstraint is called when exiting the serialDefaultColumnConstraint production. + ExitSerialDefaultColumnConstraint(c *SerialDefaultColumnConstraintContext) + + // ExitCheckColumnConstraint is called when exiting the checkColumnConstraint production. + ExitCheckColumnConstraint(c *CheckColumnConstraintContext) + + // ExitPrimaryKeyTableConstraint is called when exiting the primaryKeyTableConstraint production. + ExitPrimaryKeyTableConstraint(c *PrimaryKeyTableConstraintContext) + + // ExitUniqueKeyTableConstraint is called when exiting the uniqueKeyTableConstraint production. + ExitUniqueKeyTableConstraint(c *UniqueKeyTableConstraintContext) + + // ExitForeignKeyTableConstraint is called when exiting the foreignKeyTableConstraint production. + ExitForeignKeyTableConstraint(c *ForeignKeyTableConstraintContext) + + // ExitCheckTableConstraint is called when exiting the checkTableConstraint production. + ExitCheckTableConstraint(c *CheckTableConstraintContext) + + // ExitReferenceDefinition is called when exiting the referenceDefinition production. + ExitReferenceDefinition(c *ReferenceDefinitionContext) + + // ExitReferenceAction is called when exiting the referenceAction production. + ExitReferenceAction(c *ReferenceActionContext) + + // ExitReferenceControlType is called when exiting the referenceControlType production. + ExitReferenceControlType(c *ReferenceControlTypeContext) + + // ExitSimpleIndexDeclaration is called when exiting the simpleIndexDeclaration production. + ExitSimpleIndexDeclaration(c *SimpleIndexDeclarationContext) + + // ExitSpecialIndexDeclaration is called when exiting the specialIndexDeclaration production. + ExitSpecialIndexDeclaration(c *SpecialIndexDeclarationContext) + + // ExitTableOptionEngine is called when exiting the tableOptionEngine production. + ExitTableOptionEngine(c *TableOptionEngineContext) + + // ExitTableOptionEngineAttribute is called when exiting the tableOptionEngineAttribute production. + ExitTableOptionEngineAttribute(c *TableOptionEngineAttributeContext) + + // ExitTableOptionAutoextendSize is called when exiting the tableOptionAutoextendSize production. + ExitTableOptionAutoextendSize(c *TableOptionAutoextendSizeContext) + + // ExitTableOptionAutoIncrement is called when exiting the tableOptionAutoIncrement production. + ExitTableOptionAutoIncrement(c *TableOptionAutoIncrementContext) + + // ExitTableOptionAverage is called when exiting the tableOptionAverage production. + ExitTableOptionAverage(c *TableOptionAverageContext) + + // ExitTableOptionCharset is called when exiting the tableOptionCharset production. + ExitTableOptionCharset(c *TableOptionCharsetContext) + + // ExitTableOptionChecksum is called when exiting the tableOptionChecksum production. + ExitTableOptionChecksum(c *TableOptionChecksumContext) + + // ExitTableOptionCollate is called when exiting the tableOptionCollate production. + ExitTableOptionCollate(c *TableOptionCollateContext) + + // ExitTableOptionComment is called when exiting the tableOptionComment production. + ExitTableOptionComment(c *TableOptionCommentContext) + + // ExitTableOptionCompression is called when exiting the tableOptionCompression production. + ExitTableOptionCompression(c *TableOptionCompressionContext) + + // ExitTableOptionConnection is called when exiting the tableOptionConnection production. + ExitTableOptionConnection(c *TableOptionConnectionContext) + + // ExitTableOptionDataDirectory is called when exiting the tableOptionDataDirectory production. + ExitTableOptionDataDirectory(c *TableOptionDataDirectoryContext) + + // ExitTableOptionDelay is called when exiting the tableOptionDelay production. + ExitTableOptionDelay(c *TableOptionDelayContext) + + // ExitTableOptionEncryption is called when exiting the tableOptionEncryption production. + ExitTableOptionEncryption(c *TableOptionEncryptionContext) + + // ExitTableOptionPageCompressed is called when exiting the tableOptionPageCompressed production. + ExitTableOptionPageCompressed(c *TableOptionPageCompressedContext) + + // ExitTableOptionPageCompressionLevel is called when exiting the tableOptionPageCompressionLevel production. + ExitTableOptionPageCompressionLevel(c *TableOptionPageCompressionLevelContext) + + // ExitTableOptionEncryptionKeyId is called when exiting the tableOptionEncryptionKeyId production. + ExitTableOptionEncryptionKeyId(c *TableOptionEncryptionKeyIdContext) + + // ExitTableOptionIndexDirectory is called when exiting the tableOptionIndexDirectory production. + ExitTableOptionIndexDirectory(c *TableOptionIndexDirectoryContext) + + // ExitTableOptionInsertMethod is called when exiting the tableOptionInsertMethod production. + ExitTableOptionInsertMethod(c *TableOptionInsertMethodContext) + + // ExitTableOptionKeyBlockSize is called when exiting the tableOptionKeyBlockSize production. + ExitTableOptionKeyBlockSize(c *TableOptionKeyBlockSizeContext) + + // ExitTableOptionMaxRows is called when exiting the tableOptionMaxRows production. + ExitTableOptionMaxRows(c *TableOptionMaxRowsContext) + + // ExitTableOptionMinRows is called when exiting the tableOptionMinRows production. + ExitTableOptionMinRows(c *TableOptionMinRowsContext) + + // ExitTableOptionPackKeys is called when exiting the tableOptionPackKeys production. + ExitTableOptionPackKeys(c *TableOptionPackKeysContext) + + // ExitTableOptionPassword is called when exiting the tableOptionPassword production. + ExitTableOptionPassword(c *TableOptionPasswordContext) + + // ExitTableOptionRowFormat is called when exiting the tableOptionRowFormat production. + ExitTableOptionRowFormat(c *TableOptionRowFormatContext) + + // ExitTableOptionStartTransaction is called when exiting the tableOptionStartTransaction production. + ExitTableOptionStartTransaction(c *TableOptionStartTransactionContext) + + // ExitTableOptionSecondaryEngineAttribute is called when exiting the tableOptionSecondaryEngineAttribute production. + ExitTableOptionSecondaryEngineAttribute(c *TableOptionSecondaryEngineAttributeContext) + + // ExitTableOptionRecalculation is called when exiting the tableOptionRecalculation production. + ExitTableOptionRecalculation(c *TableOptionRecalculationContext) + + // ExitTableOptionPersistent is called when exiting the tableOptionPersistent production. + ExitTableOptionPersistent(c *TableOptionPersistentContext) + + // ExitTableOptionSamplePage is called when exiting the tableOptionSamplePage production. + ExitTableOptionSamplePage(c *TableOptionSamplePageContext) + + // ExitTableOptionTablespace is called when exiting the tableOptionTablespace production. + ExitTableOptionTablespace(c *TableOptionTablespaceContext) + + // ExitTableOptionTableType is called when exiting the tableOptionTableType production. + ExitTableOptionTableType(c *TableOptionTableTypeContext) + + // ExitTableOptionTransactional is called when exiting the tableOptionTransactional production. + ExitTableOptionTransactional(c *TableOptionTransactionalContext) + + // ExitTableOptionUnion is called when exiting the tableOptionUnion production. + ExitTableOptionUnion(c *TableOptionUnionContext) + + // ExitTableType is called when exiting the tableType production. + ExitTableType(c *TableTypeContext) + + // ExitTablespaceStorage is called when exiting the tablespaceStorage production. + ExitTablespaceStorage(c *TablespaceStorageContext) + + // ExitPartitionDefinitions is called when exiting the partitionDefinitions production. + ExitPartitionDefinitions(c *PartitionDefinitionsContext) + + // ExitPartitionFunctionHash is called when exiting the partitionFunctionHash production. + ExitPartitionFunctionHash(c *PartitionFunctionHashContext) + + // ExitPartitionFunctionKey is called when exiting the partitionFunctionKey production. + ExitPartitionFunctionKey(c *PartitionFunctionKeyContext) + + // ExitPartitionFunctionRange is called when exiting the partitionFunctionRange production. + ExitPartitionFunctionRange(c *PartitionFunctionRangeContext) + + // ExitPartitionFunctionList is called when exiting the partitionFunctionList production. + ExitPartitionFunctionList(c *PartitionFunctionListContext) + + // ExitSubPartitionFunctionHash is called when exiting the subPartitionFunctionHash production. + ExitSubPartitionFunctionHash(c *SubPartitionFunctionHashContext) + + // ExitSubPartitionFunctionKey is called when exiting the subPartitionFunctionKey production. + ExitSubPartitionFunctionKey(c *SubPartitionFunctionKeyContext) + + // ExitPartitionComparison is called when exiting the partitionComparison production. + ExitPartitionComparison(c *PartitionComparisonContext) + + // ExitPartitionListAtom is called when exiting the partitionListAtom production. + ExitPartitionListAtom(c *PartitionListAtomContext) + + // ExitPartitionListVector is called when exiting the partitionListVector production. + ExitPartitionListVector(c *PartitionListVectorContext) + + // ExitPartitionSimple is called when exiting the partitionSimple production. + ExitPartitionSimple(c *PartitionSimpleContext) + + // ExitPartitionDefinerAtom is called when exiting the partitionDefinerAtom production. + ExitPartitionDefinerAtom(c *PartitionDefinerAtomContext) + + // ExitPartitionDefinerVector is called when exiting the partitionDefinerVector production. + ExitPartitionDefinerVector(c *PartitionDefinerVectorContext) + + // ExitSubpartitionDefinition is called when exiting the subpartitionDefinition production. + ExitSubpartitionDefinition(c *SubpartitionDefinitionContext) + + // ExitPartitionOptionEngine is called when exiting the partitionOptionEngine production. + ExitPartitionOptionEngine(c *PartitionOptionEngineContext) + + // ExitPartitionOptionComment is called when exiting the partitionOptionComment production. + ExitPartitionOptionComment(c *PartitionOptionCommentContext) + + // ExitPartitionOptionDataDirectory is called when exiting the partitionOptionDataDirectory production. + ExitPartitionOptionDataDirectory(c *PartitionOptionDataDirectoryContext) + + // ExitPartitionOptionIndexDirectory is called when exiting the partitionOptionIndexDirectory production. + ExitPartitionOptionIndexDirectory(c *PartitionOptionIndexDirectoryContext) + + // ExitPartitionOptionMaxRows is called when exiting the partitionOptionMaxRows production. + ExitPartitionOptionMaxRows(c *PartitionOptionMaxRowsContext) + + // ExitPartitionOptionMinRows is called when exiting the partitionOptionMinRows production. + ExitPartitionOptionMinRows(c *PartitionOptionMinRowsContext) + + // ExitPartitionOptionTablespace is called when exiting the partitionOptionTablespace production. + ExitPartitionOptionTablespace(c *PartitionOptionTablespaceContext) + + // ExitPartitionOptionNodeGroup is called when exiting the partitionOptionNodeGroup production. + ExitPartitionOptionNodeGroup(c *PartitionOptionNodeGroupContext) + + // ExitAlterSimpleDatabase is called when exiting the alterSimpleDatabase production. + ExitAlterSimpleDatabase(c *AlterSimpleDatabaseContext) + + // ExitAlterUpgradeName is called when exiting the alterUpgradeName production. + ExitAlterUpgradeName(c *AlterUpgradeNameContext) + + // ExitAlterEvent is called when exiting the alterEvent production. + ExitAlterEvent(c *AlterEventContext) + + // ExitAlterFunction is called when exiting the alterFunction production. + ExitAlterFunction(c *AlterFunctionContext) + + // ExitAlterInstance is called when exiting the alterInstance production. + ExitAlterInstance(c *AlterInstanceContext) + + // ExitAlterLogfileGroup is called when exiting the alterLogfileGroup production. + ExitAlterLogfileGroup(c *AlterLogfileGroupContext) + + // ExitAlterProcedure is called when exiting the alterProcedure production. + ExitAlterProcedure(c *AlterProcedureContext) + + // ExitAlterServer is called when exiting the alterServer production. + ExitAlterServer(c *AlterServerContext) + + // ExitAlterTable is called when exiting the alterTable production. + ExitAlterTable(c *AlterTableContext) + + // ExitAlterTablespace is called when exiting the alterTablespace production. + ExitAlterTablespace(c *AlterTablespaceContext) + + // ExitAlterView is called when exiting the alterView production. + ExitAlterView(c *AlterViewContext) + + // ExitAlterByTableOption is called when exiting the alterByTableOption production. + ExitAlterByTableOption(c *AlterByTableOptionContext) + + // ExitAlterByAddColumn is called when exiting the alterByAddColumn production. + ExitAlterByAddColumn(c *AlterByAddColumnContext) + + // ExitAlterByAddColumns is called when exiting the alterByAddColumns production. + ExitAlterByAddColumns(c *AlterByAddColumnsContext) + + // ExitAlterByAddIndex is called when exiting the alterByAddIndex production. + ExitAlterByAddIndex(c *AlterByAddIndexContext) + + // ExitAlterByAddPrimaryKey is called when exiting the alterByAddPrimaryKey production. + ExitAlterByAddPrimaryKey(c *AlterByAddPrimaryKeyContext) + + // ExitAlterByAddUniqueKey is called when exiting the alterByAddUniqueKey production. + ExitAlterByAddUniqueKey(c *AlterByAddUniqueKeyContext) + + // ExitAlterByAddSpecialIndex is called when exiting the alterByAddSpecialIndex production. + ExitAlterByAddSpecialIndex(c *AlterByAddSpecialIndexContext) + + // ExitAlterByAddForeignKey is called when exiting the alterByAddForeignKey production. + ExitAlterByAddForeignKey(c *AlterByAddForeignKeyContext) + + // ExitAlterByAddCheckTableConstraint is called when exiting the alterByAddCheckTableConstraint production. + ExitAlterByAddCheckTableConstraint(c *AlterByAddCheckTableConstraintContext) + + // ExitAlterByAlterCheckTableConstraint is called when exiting the alterByAlterCheckTableConstraint production. + ExitAlterByAlterCheckTableConstraint(c *AlterByAlterCheckTableConstraintContext) + + // ExitAlterBySetAlgorithm is called when exiting the alterBySetAlgorithm production. + ExitAlterBySetAlgorithm(c *AlterBySetAlgorithmContext) + + // ExitAlterByChangeDefault is called when exiting the alterByChangeDefault production. + ExitAlterByChangeDefault(c *AlterByChangeDefaultContext) + + // ExitAlterByChangeColumn is called when exiting the alterByChangeColumn production. + ExitAlterByChangeColumn(c *AlterByChangeColumnContext) + + // ExitAlterByRenameColumn is called when exiting the alterByRenameColumn production. + ExitAlterByRenameColumn(c *AlterByRenameColumnContext) + + // ExitAlterByLock is called when exiting the alterByLock production. + ExitAlterByLock(c *AlterByLockContext) + + // ExitAlterByModifyColumn is called when exiting the alterByModifyColumn production. + ExitAlterByModifyColumn(c *AlterByModifyColumnContext) + + // ExitAlterByDropColumn is called when exiting the alterByDropColumn production. + ExitAlterByDropColumn(c *AlterByDropColumnContext) + + // ExitAlterByDropConstraintCheck is called when exiting the alterByDropConstraintCheck production. + ExitAlterByDropConstraintCheck(c *AlterByDropConstraintCheckContext) + + // ExitAlterByDropPrimaryKey is called when exiting the alterByDropPrimaryKey production. + ExitAlterByDropPrimaryKey(c *AlterByDropPrimaryKeyContext) + + // ExitAlterByDropIndex is called when exiting the alterByDropIndex production. + ExitAlterByDropIndex(c *AlterByDropIndexContext) + + // ExitAlterByRenameIndex is called when exiting the alterByRenameIndex production. + ExitAlterByRenameIndex(c *AlterByRenameIndexContext) + + // ExitAlterByAlterColumnDefault is called when exiting the alterByAlterColumnDefault production. + ExitAlterByAlterColumnDefault(c *AlterByAlterColumnDefaultContext) + + // ExitAlterByAlterIndexVisibility is called when exiting the alterByAlterIndexVisibility production. + ExitAlterByAlterIndexVisibility(c *AlterByAlterIndexVisibilityContext) + + // ExitAlterByDropForeignKey is called when exiting the alterByDropForeignKey production. + ExitAlterByDropForeignKey(c *AlterByDropForeignKeyContext) + + // ExitAlterByDisableKeys is called when exiting the alterByDisableKeys production. + ExitAlterByDisableKeys(c *AlterByDisableKeysContext) + + // ExitAlterByEnableKeys is called when exiting the alterByEnableKeys production. + ExitAlterByEnableKeys(c *AlterByEnableKeysContext) + + // ExitAlterByRename is called when exiting the alterByRename production. + ExitAlterByRename(c *AlterByRenameContext) + + // ExitAlterByOrder is called when exiting the alterByOrder production. + ExitAlterByOrder(c *AlterByOrderContext) + + // ExitAlterByConvertCharset is called when exiting the alterByConvertCharset production. + ExitAlterByConvertCharset(c *AlterByConvertCharsetContext) + + // ExitAlterByDefaultCharset is called when exiting the alterByDefaultCharset production. + ExitAlterByDefaultCharset(c *AlterByDefaultCharsetContext) + + // ExitAlterByDiscardTablespace is called when exiting the alterByDiscardTablespace production. + ExitAlterByDiscardTablespace(c *AlterByDiscardTablespaceContext) + + // ExitAlterByImportTablespace is called when exiting the alterByImportTablespace production. + ExitAlterByImportTablespace(c *AlterByImportTablespaceContext) + + // ExitAlterByForce is called when exiting the alterByForce production. + ExitAlterByForce(c *AlterByForceContext) + + // ExitAlterByValidate is called when exiting the alterByValidate production. + ExitAlterByValidate(c *AlterByValidateContext) + + // ExitAlterByAddDefinitions is called when exiting the alterByAddDefinitions production. + ExitAlterByAddDefinitions(c *AlterByAddDefinitionsContext) + + // ExitAlterPartition is called when exiting the alterPartition production. + ExitAlterPartition(c *AlterPartitionContext) + + // ExitAlterByAddPartition is called when exiting the alterByAddPartition production. + ExitAlterByAddPartition(c *AlterByAddPartitionContext) + + // ExitAlterByDropPartition is called when exiting the alterByDropPartition production. + ExitAlterByDropPartition(c *AlterByDropPartitionContext) + + // ExitAlterByDiscardPartition is called when exiting the alterByDiscardPartition production. + ExitAlterByDiscardPartition(c *AlterByDiscardPartitionContext) + + // ExitAlterByImportPartition is called when exiting the alterByImportPartition production. + ExitAlterByImportPartition(c *AlterByImportPartitionContext) + + // ExitAlterByTruncatePartition is called when exiting the alterByTruncatePartition production. + ExitAlterByTruncatePartition(c *AlterByTruncatePartitionContext) + + // ExitAlterByCoalescePartition is called when exiting the alterByCoalescePartition production. + ExitAlterByCoalescePartition(c *AlterByCoalescePartitionContext) + + // ExitAlterByReorganizePartition is called when exiting the alterByReorganizePartition production. + ExitAlterByReorganizePartition(c *AlterByReorganizePartitionContext) + + // ExitAlterByExchangePartition is called when exiting the alterByExchangePartition production. + ExitAlterByExchangePartition(c *AlterByExchangePartitionContext) + + // ExitAlterByAnalyzePartition is called when exiting the alterByAnalyzePartition production. + ExitAlterByAnalyzePartition(c *AlterByAnalyzePartitionContext) + + // ExitAlterByCheckPartition is called when exiting the alterByCheckPartition production. + ExitAlterByCheckPartition(c *AlterByCheckPartitionContext) + + // ExitAlterByOptimizePartition is called when exiting the alterByOptimizePartition production. + ExitAlterByOptimizePartition(c *AlterByOptimizePartitionContext) + + // ExitAlterByRebuildPartition is called when exiting the alterByRebuildPartition production. + ExitAlterByRebuildPartition(c *AlterByRebuildPartitionContext) + + // ExitAlterByRepairPartition is called when exiting the alterByRepairPartition production. + ExitAlterByRepairPartition(c *AlterByRepairPartitionContext) + + // ExitAlterByRemovePartitioning is called when exiting the alterByRemovePartitioning production. + ExitAlterByRemovePartitioning(c *AlterByRemovePartitioningContext) + + // ExitAlterByUpgradePartitioning is called when exiting the alterByUpgradePartitioning production. + ExitAlterByUpgradePartitioning(c *AlterByUpgradePartitioningContext) + + // ExitDropDatabase is called when exiting the dropDatabase production. + ExitDropDatabase(c *DropDatabaseContext) + + // ExitDropEvent is called when exiting the dropEvent production. + ExitDropEvent(c *DropEventContext) + + // ExitDropIndex is called when exiting the dropIndex production. + ExitDropIndex(c *DropIndexContext) + + // ExitDropLogfileGroup is called when exiting the dropLogfileGroup production. + ExitDropLogfileGroup(c *DropLogfileGroupContext) + + // ExitDropProcedure is called when exiting the dropProcedure production. + ExitDropProcedure(c *DropProcedureContext) + + // ExitDropFunction is called when exiting the dropFunction production. + ExitDropFunction(c *DropFunctionContext) + + // ExitDropServer is called when exiting the dropServer production. + ExitDropServer(c *DropServerContext) + + // ExitDropTable is called when exiting the dropTable production. + ExitDropTable(c *DropTableContext) + + // ExitDropTablespace is called when exiting the dropTablespace production. + ExitDropTablespace(c *DropTablespaceContext) + + // ExitDropTrigger is called when exiting the dropTrigger production. + ExitDropTrigger(c *DropTriggerContext) + + // ExitDropView is called when exiting the dropView production. + ExitDropView(c *DropViewContext) + + // ExitDropRole is called when exiting the dropRole production. + ExitDropRole(c *DropRoleContext) + + // ExitSetRole is called when exiting the setRole production. + ExitSetRole(c *SetRoleContext) + + // ExitRenameTable is called when exiting the renameTable production. + ExitRenameTable(c *RenameTableContext) + + // ExitRenameTableClause is called when exiting the renameTableClause production. + ExitRenameTableClause(c *RenameTableClauseContext) + + // ExitTruncateTable is called when exiting the truncateTable production. + ExitTruncateTable(c *TruncateTableContext) + + // ExitCallStatement is called when exiting the callStatement production. + ExitCallStatement(c *CallStatementContext) + + // ExitDeleteStatement is called when exiting the deleteStatement production. + ExitDeleteStatement(c *DeleteStatementContext) + + // ExitDoStatement is called when exiting the doStatement production. + ExitDoStatement(c *DoStatementContext) + + // ExitHandlerStatement is called when exiting the handlerStatement production. + ExitHandlerStatement(c *HandlerStatementContext) + + // ExitInsertStatement is called when exiting the insertStatement production. + ExitInsertStatement(c *InsertStatementContext) + + // ExitLoadDataStatement is called when exiting the loadDataStatement production. + ExitLoadDataStatement(c *LoadDataStatementContext) + + // ExitLoadXmlStatement is called when exiting the loadXmlStatement production. + ExitLoadXmlStatement(c *LoadXmlStatementContext) + + // ExitReplaceStatement is called when exiting the replaceStatement production. + ExitReplaceStatement(c *ReplaceStatementContext) + + // ExitSimpleSelect is called when exiting the simpleSelect production. + ExitSimpleSelect(c *SimpleSelectContext) + + // ExitParenthesisSelect is called when exiting the parenthesisSelect production. + ExitParenthesisSelect(c *ParenthesisSelectContext) + + // ExitUnionSelect is called when exiting the unionSelect production. + ExitUnionSelect(c *UnionSelectContext) + + // ExitUnionParenthesisSelect is called when exiting the unionParenthesisSelect production. + ExitUnionParenthesisSelect(c *UnionParenthesisSelectContext) + + // ExitWithLateralStatement is called when exiting the withLateralStatement production. + ExitWithLateralStatement(c *WithLateralStatementContext) + + // ExitUpdateStatement is called when exiting the updateStatement production. + ExitUpdateStatement(c *UpdateStatementContext) + + // ExitValuesStatement is called when exiting the valuesStatement production. + ExitValuesStatement(c *ValuesStatementContext) + + // ExitInsertStatementValue is called when exiting the insertStatementValue production. + ExitInsertStatementValue(c *InsertStatementValueContext) + + // ExitUpdatedElement is called when exiting the updatedElement production. + ExitUpdatedElement(c *UpdatedElementContext) + + // ExitAssignmentField is called when exiting the assignmentField production. + ExitAssignmentField(c *AssignmentFieldContext) + + // ExitLockClause is called when exiting the lockClause production. + ExitLockClause(c *LockClauseContext) + + // ExitSingleDeleteStatement is called when exiting the singleDeleteStatement production. + ExitSingleDeleteStatement(c *SingleDeleteStatementContext) + + // ExitMultipleDeleteStatement is called when exiting the multipleDeleteStatement production. + ExitMultipleDeleteStatement(c *MultipleDeleteStatementContext) + + // ExitHandlerOpenStatement is called when exiting the handlerOpenStatement production. + ExitHandlerOpenStatement(c *HandlerOpenStatementContext) + + // ExitHandlerReadIndexStatement is called when exiting the handlerReadIndexStatement production. + ExitHandlerReadIndexStatement(c *HandlerReadIndexStatementContext) + + // ExitHandlerReadStatement is called when exiting the handlerReadStatement production. + ExitHandlerReadStatement(c *HandlerReadStatementContext) + + // ExitHandlerCloseStatement is called when exiting the handlerCloseStatement production. + ExitHandlerCloseStatement(c *HandlerCloseStatementContext) + + // ExitSingleUpdateStatement is called when exiting the singleUpdateStatement production. + ExitSingleUpdateStatement(c *SingleUpdateStatementContext) + + // ExitMultipleUpdateStatement is called when exiting the multipleUpdateStatement production. + ExitMultipleUpdateStatement(c *MultipleUpdateStatementContext) + + // ExitOrderByClause is called when exiting the orderByClause production. + ExitOrderByClause(c *OrderByClauseContext) + + // ExitOrderByExpression is called when exiting the orderByExpression production. + ExitOrderByExpression(c *OrderByExpressionContext) + + // ExitTableSources is called when exiting the tableSources production. + ExitTableSources(c *TableSourcesContext) + + // ExitTableSourceBase is called when exiting the tableSourceBase production. + ExitTableSourceBase(c *TableSourceBaseContext) + + // ExitTableSourceNested is called when exiting the tableSourceNested production. + ExitTableSourceNested(c *TableSourceNestedContext) + + // ExitTableJson is called when exiting the tableJson production. + ExitTableJson(c *TableJsonContext) + + // ExitAtomTableItem is called when exiting the atomTableItem production. + ExitAtomTableItem(c *AtomTableItemContext) + + // ExitSubqueryTableItem is called when exiting the subqueryTableItem production. + ExitSubqueryTableItem(c *SubqueryTableItemContext) + + // ExitTableSourcesItem is called when exiting the tableSourcesItem production. + ExitTableSourcesItem(c *TableSourcesItemContext) + + // ExitIndexHint is called when exiting the indexHint production. + ExitIndexHint(c *IndexHintContext) + + // ExitIndexHintType is called when exiting the indexHintType production. + ExitIndexHintType(c *IndexHintTypeContext) + + // ExitInnerJoin is called when exiting the innerJoin production. + ExitInnerJoin(c *InnerJoinContext) + + // ExitStraightJoin is called when exiting the straightJoin production. + ExitStraightJoin(c *StraightJoinContext) + + // ExitOuterJoin is called when exiting the outerJoin production. + ExitOuterJoin(c *OuterJoinContext) + + // ExitNaturalJoin is called when exiting the naturalJoin production. + ExitNaturalJoin(c *NaturalJoinContext) + + // ExitJoinSpec is called when exiting the joinSpec production. + ExitJoinSpec(c *JoinSpecContext) + + // ExitQueryExpression is called when exiting the queryExpression production. + ExitQueryExpression(c *QueryExpressionContext) + + // ExitQueryExpressionNointo is called when exiting the queryExpressionNointo production. + ExitQueryExpressionNointo(c *QueryExpressionNointoContext) + + // ExitQuerySpecification is called when exiting the querySpecification production. + ExitQuerySpecification(c *QuerySpecificationContext) + + // ExitQuerySpecificationNointo is called when exiting the querySpecificationNointo production. + ExitQuerySpecificationNointo(c *QuerySpecificationNointoContext) + + // ExitUnionParenthesis is called when exiting the unionParenthesis production. + ExitUnionParenthesis(c *UnionParenthesisContext) + + // ExitUnionStatement is called when exiting the unionStatement production. + ExitUnionStatement(c *UnionStatementContext) + + // ExitLateralStatement is called when exiting the lateralStatement production. + ExitLateralStatement(c *LateralStatementContext) + + // ExitJsonTable is called when exiting the jsonTable production. + ExitJsonTable(c *JsonTableContext) + + // ExitJsonColumnList is called when exiting the jsonColumnList production. + ExitJsonColumnList(c *JsonColumnListContext) + + // ExitJsonColumn is called when exiting the jsonColumn production. + ExitJsonColumn(c *JsonColumnContext) + + // ExitJsonOnEmpty is called when exiting the jsonOnEmpty production. + ExitJsonOnEmpty(c *JsonOnEmptyContext) + + // ExitJsonOnError is called when exiting the jsonOnError production. + ExitJsonOnError(c *JsonOnErrorContext) + + // ExitSelectSpec is called when exiting the selectSpec production. + ExitSelectSpec(c *SelectSpecContext) + + // ExitSelectElements is called when exiting the selectElements production. + ExitSelectElements(c *SelectElementsContext) + + // ExitSelectStarElement is called when exiting the selectStarElement production. + ExitSelectStarElement(c *SelectStarElementContext) + + // ExitSelectColumnElement is called when exiting the selectColumnElement production. + ExitSelectColumnElement(c *SelectColumnElementContext) + + // ExitSelectFunctionElement is called when exiting the selectFunctionElement production. + ExitSelectFunctionElement(c *SelectFunctionElementContext) + + // ExitSelectExpressionElement is called when exiting the selectExpressionElement production. + ExitSelectExpressionElement(c *SelectExpressionElementContext) + + // ExitSelectIntoVariables is called when exiting the selectIntoVariables production. + ExitSelectIntoVariables(c *SelectIntoVariablesContext) + + // ExitSelectIntoDumpFile is called when exiting the selectIntoDumpFile production. + ExitSelectIntoDumpFile(c *SelectIntoDumpFileContext) + + // ExitSelectIntoTextFile is called when exiting the selectIntoTextFile production. + ExitSelectIntoTextFile(c *SelectIntoTextFileContext) + + // ExitSelectFieldsInto is called when exiting the selectFieldsInto production. + ExitSelectFieldsInto(c *SelectFieldsIntoContext) + + // ExitSelectLinesInto is called when exiting the selectLinesInto production. + ExitSelectLinesInto(c *SelectLinesIntoContext) + + // ExitFromClause is called when exiting the fromClause production. + ExitFromClause(c *FromClauseContext) + + // ExitGroupByClause is called when exiting the groupByClause production. + ExitGroupByClause(c *GroupByClauseContext) + + // ExitHavingClause is called when exiting the havingClause production. + ExitHavingClause(c *HavingClauseContext) + + // ExitWindowClause is called when exiting the windowClause production. + ExitWindowClause(c *WindowClauseContext) + + // ExitGroupByItem is called when exiting the groupByItem production. + ExitGroupByItem(c *GroupByItemContext) + + // ExitLimitClause is called when exiting the limitClause production. + ExitLimitClause(c *LimitClauseContext) + + // ExitLimitClauseAtom is called when exiting the limitClauseAtom production. + ExitLimitClauseAtom(c *LimitClauseAtomContext) + + // ExitStartTransaction is called when exiting the startTransaction production. + ExitStartTransaction(c *StartTransactionContext) + + // ExitBeginWork is called when exiting the beginWork production. + ExitBeginWork(c *BeginWorkContext) + + // ExitCommitWork is called when exiting the commitWork production. + ExitCommitWork(c *CommitWorkContext) + + // ExitRollbackWork is called when exiting the rollbackWork production. + ExitRollbackWork(c *RollbackWorkContext) + + // ExitSavepointStatement is called when exiting the savepointStatement production. + ExitSavepointStatement(c *SavepointStatementContext) + + // ExitRollbackStatement is called when exiting the rollbackStatement production. + ExitRollbackStatement(c *RollbackStatementContext) + + // ExitReleaseStatement is called when exiting the releaseStatement production. + ExitReleaseStatement(c *ReleaseStatementContext) + + // ExitLockTables is called when exiting the lockTables production. + ExitLockTables(c *LockTablesContext) + + // ExitUnlockTables is called when exiting the unlockTables production. + ExitUnlockTables(c *UnlockTablesContext) + + // ExitSetAutocommitStatement is called when exiting the setAutocommitStatement production. + ExitSetAutocommitStatement(c *SetAutocommitStatementContext) + + // ExitSetTransactionStatement is called when exiting the setTransactionStatement production. + ExitSetTransactionStatement(c *SetTransactionStatementContext) + + // ExitTransactionMode is called when exiting the transactionMode production. + ExitTransactionMode(c *TransactionModeContext) + + // ExitLockTableElement is called when exiting the lockTableElement production. + ExitLockTableElement(c *LockTableElementContext) + + // ExitLockAction is called when exiting the lockAction production. + ExitLockAction(c *LockActionContext) + + // ExitTransactionOption is called when exiting the transactionOption production. + ExitTransactionOption(c *TransactionOptionContext) + + // ExitTransactionLevel is called when exiting the transactionLevel production. + ExitTransactionLevel(c *TransactionLevelContext) + + // ExitChangeMaster is called when exiting the changeMaster production. + ExitChangeMaster(c *ChangeMasterContext) + + // ExitChangeReplicationFilter is called when exiting the changeReplicationFilter production. + ExitChangeReplicationFilter(c *ChangeReplicationFilterContext) + + // ExitPurgeBinaryLogs is called when exiting the purgeBinaryLogs production. + ExitPurgeBinaryLogs(c *PurgeBinaryLogsContext) + + // ExitResetMaster is called when exiting the resetMaster production. + ExitResetMaster(c *ResetMasterContext) + + // ExitResetSlave is called when exiting the resetSlave production. + ExitResetSlave(c *ResetSlaveContext) + + // ExitStartSlave is called when exiting the startSlave production. + ExitStartSlave(c *StartSlaveContext) + + // ExitStopSlave is called when exiting the stopSlave production. + ExitStopSlave(c *StopSlaveContext) + + // ExitStartGroupReplication is called when exiting the startGroupReplication production. + ExitStartGroupReplication(c *StartGroupReplicationContext) + + // ExitStopGroupReplication is called when exiting the stopGroupReplication production. + ExitStopGroupReplication(c *StopGroupReplicationContext) + + // ExitMasterStringOption is called when exiting the masterStringOption production. + ExitMasterStringOption(c *MasterStringOptionContext) + + // ExitMasterDecimalOption is called when exiting the masterDecimalOption production. + ExitMasterDecimalOption(c *MasterDecimalOptionContext) + + // ExitMasterBoolOption is called when exiting the masterBoolOption production. + ExitMasterBoolOption(c *MasterBoolOptionContext) + + // ExitMasterRealOption is called when exiting the masterRealOption production. + ExitMasterRealOption(c *MasterRealOptionContext) + + // ExitMasterUidListOption is called when exiting the masterUidListOption production. + ExitMasterUidListOption(c *MasterUidListOptionContext) + + // ExitStringMasterOption is called when exiting the stringMasterOption production. + ExitStringMasterOption(c *StringMasterOptionContext) + + // ExitDecimalMasterOption is called when exiting the decimalMasterOption production. + ExitDecimalMasterOption(c *DecimalMasterOptionContext) + + // ExitBoolMasterOption is called when exiting the boolMasterOption production. + ExitBoolMasterOption(c *BoolMasterOptionContext) + + // ExitChannelOption is called when exiting the channelOption production. + ExitChannelOption(c *ChannelOptionContext) + + // ExitDoDbReplication is called when exiting the doDbReplication production. + ExitDoDbReplication(c *DoDbReplicationContext) + + // ExitIgnoreDbReplication is called when exiting the ignoreDbReplication production. + ExitIgnoreDbReplication(c *IgnoreDbReplicationContext) + + // ExitDoTableReplication is called when exiting the doTableReplication production. + ExitDoTableReplication(c *DoTableReplicationContext) + + // ExitIgnoreTableReplication is called when exiting the ignoreTableReplication production. + ExitIgnoreTableReplication(c *IgnoreTableReplicationContext) + + // ExitWildDoTableReplication is called when exiting the wildDoTableReplication production. + ExitWildDoTableReplication(c *WildDoTableReplicationContext) + + // ExitWildIgnoreTableReplication is called when exiting the wildIgnoreTableReplication production. + ExitWildIgnoreTableReplication(c *WildIgnoreTableReplicationContext) + + // ExitRewriteDbReplication is called when exiting the rewriteDbReplication production. + ExitRewriteDbReplication(c *RewriteDbReplicationContext) + + // ExitTablePair is called when exiting the tablePair production. + ExitTablePair(c *TablePairContext) + + // ExitThreadType is called when exiting the threadType production. + ExitThreadType(c *ThreadTypeContext) + + // ExitGtidsUntilOption is called when exiting the gtidsUntilOption production. + ExitGtidsUntilOption(c *GtidsUntilOptionContext) + + // ExitMasterLogUntilOption is called when exiting the masterLogUntilOption production. + ExitMasterLogUntilOption(c *MasterLogUntilOptionContext) + + // ExitRelayLogUntilOption is called when exiting the relayLogUntilOption production. + ExitRelayLogUntilOption(c *RelayLogUntilOptionContext) + + // ExitSqlGapsUntilOption is called when exiting the sqlGapsUntilOption production. + ExitSqlGapsUntilOption(c *SqlGapsUntilOptionContext) + + // ExitUserConnectionOption is called when exiting the userConnectionOption production. + ExitUserConnectionOption(c *UserConnectionOptionContext) + + // ExitPasswordConnectionOption is called when exiting the passwordConnectionOption production. + ExitPasswordConnectionOption(c *PasswordConnectionOptionContext) + + // ExitDefaultAuthConnectionOption is called when exiting the defaultAuthConnectionOption production. + ExitDefaultAuthConnectionOption(c *DefaultAuthConnectionOptionContext) + + // ExitPluginDirConnectionOption is called when exiting the pluginDirConnectionOption production. + ExitPluginDirConnectionOption(c *PluginDirConnectionOptionContext) + + // ExitGtuidSet is called when exiting the gtuidSet production. + ExitGtuidSet(c *GtuidSetContext) + + // ExitXaStartTransaction is called when exiting the xaStartTransaction production. + ExitXaStartTransaction(c *XaStartTransactionContext) + + // ExitXaEndTransaction is called when exiting the xaEndTransaction production. + ExitXaEndTransaction(c *XaEndTransactionContext) + + // ExitXaPrepareStatement is called when exiting the xaPrepareStatement production. + ExitXaPrepareStatement(c *XaPrepareStatementContext) + + // ExitXaCommitWork is called when exiting the xaCommitWork production. + ExitXaCommitWork(c *XaCommitWorkContext) + + // ExitXaRollbackWork is called when exiting the xaRollbackWork production. + ExitXaRollbackWork(c *XaRollbackWorkContext) + + // ExitXaRecoverWork is called when exiting the xaRecoverWork production. + ExitXaRecoverWork(c *XaRecoverWorkContext) + + // ExitPrepareStatement is called when exiting the prepareStatement production. + ExitPrepareStatement(c *PrepareStatementContext) + + // ExitExecuteStatement is called when exiting the executeStatement production. + ExitExecuteStatement(c *ExecuteStatementContext) + + // ExitDeallocatePrepare is called when exiting the deallocatePrepare production. + ExitDeallocatePrepare(c *DeallocatePrepareContext) + + // ExitRoutineBody is called when exiting the routineBody production. + ExitRoutineBody(c *RoutineBodyContext) + + // ExitBlockStatement is called when exiting the blockStatement production. + ExitBlockStatement(c *BlockStatementContext) + + // ExitCaseStatement is called when exiting the caseStatement production. + ExitCaseStatement(c *CaseStatementContext) + + // ExitIfStatement is called when exiting the ifStatement production. + ExitIfStatement(c *IfStatementContext) + + // ExitIterateStatement is called when exiting the iterateStatement production. + ExitIterateStatement(c *IterateStatementContext) + + // ExitLeaveStatement is called when exiting the leaveStatement production. + ExitLeaveStatement(c *LeaveStatementContext) + + // ExitLoopStatement is called when exiting the loopStatement production. + ExitLoopStatement(c *LoopStatementContext) + + // ExitRepeatStatement is called when exiting the repeatStatement production. + ExitRepeatStatement(c *RepeatStatementContext) + + // ExitReturnStatement is called when exiting the returnStatement production. + ExitReturnStatement(c *ReturnStatementContext) + + // ExitWhileStatement is called when exiting the whileStatement production. + ExitWhileStatement(c *WhileStatementContext) + + // ExitCloseCursor is called when exiting the CloseCursor production. + ExitCloseCursor(c *CloseCursorContext) + + // ExitFetchCursor is called when exiting the FetchCursor production. + ExitFetchCursor(c *FetchCursorContext) + + // ExitOpenCursor is called when exiting the OpenCursor production. + ExitOpenCursor(c *OpenCursorContext) + + // ExitDeclareVariable is called when exiting the declareVariable production. + ExitDeclareVariable(c *DeclareVariableContext) + + // ExitDeclareCondition is called when exiting the declareCondition production. + ExitDeclareCondition(c *DeclareConditionContext) + + // ExitDeclareCursor is called when exiting the declareCursor production. + ExitDeclareCursor(c *DeclareCursorContext) + + // ExitDeclareHandler is called when exiting the declareHandler production. + ExitDeclareHandler(c *DeclareHandlerContext) + + // ExitHandlerConditionCode is called when exiting the handlerConditionCode production. + ExitHandlerConditionCode(c *HandlerConditionCodeContext) + + // ExitHandlerConditionState is called when exiting the handlerConditionState production. + ExitHandlerConditionState(c *HandlerConditionStateContext) + + // ExitHandlerConditionName is called when exiting the handlerConditionName production. + ExitHandlerConditionName(c *HandlerConditionNameContext) + + // ExitHandlerConditionWarning is called when exiting the handlerConditionWarning production. + ExitHandlerConditionWarning(c *HandlerConditionWarningContext) + + // ExitHandlerConditionNotfound is called when exiting the handlerConditionNotfound production. + ExitHandlerConditionNotfound(c *HandlerConditionNotfoundContext) + + // ExitHandlerConditionException is called when exiting the handlerConditionException production. + ExitHandlerConditionException(c *HandlerConditionExceptionContext) + + // ExitProcedureSqlStatement is called when exiting the procedureSqlStatement production. + ExitProcedureSqlStatement(c *ProcedureSqlStatementContext) + + // ExitCaseAlternative is called when exiting the caseAlternative production. + ExitCaseAlternative(c *CaseAlternativeContext) + + // ExitElifAlternative is called when exiting the elifAlternative production. + ExitElifAlternative(c *ElifAlternativeContext) + + // ExitAlterUserMysqlV56 is called when exiting the alterUserMysqlV56 production. + ExitAlterUserMysqlV56(c *AlterUserMysqlV56Context) + + // ExitAlterUserMysqlV80 is called when exiting the alterUserMysqlV80 production. + ExitAlterUserMysqlV80(c *AlterUserMysqlV80Context) + + // ExitCreateUserMysqlV56 is called when exiting the createUserMysqlV56 production. + ExitCreateUserMysqlV56(c *CreateUserMysqlV56Context) + + // ExitCreateUserMysqlV80 is called when exiting the createUserMysqlV80 production. + ExitCreateUserMysqlV80(c *CreateUserMysqlV80Context) + + // ExitDropUser is called when exiting the dropUser production. + ExitDropUser(c *DropUserContext) + + // ExitGrantStatement is called when exiting the grantStatement production. + ExitGrantStatement(c *GrantStatementContext) + + // ExitRoleOption is called when exiting the roleOption production. + ExitRoleOption(c *RoleOptionContext) + + // ExitGrantProxy is called when exiting the grantProxy production. + ExitGrantProxy(c *GrantProxyContext) + + // ExitRenameUser is called when exiting the renameUser production. + ExitRenameUser(c *RenameUserContext) + + // ExitDetailRevoke is called when exiting the detailRevoke production. + ExitDetailRevoke(c *DetailRevokeContext) + + // ExitShortRevoke is called when exiting the shortRevoke production. + ExitShortRevoke(c *ShortRevokeContext) + + // ExitRoleRevoke is called when exiting the roleRevoke production. + ExitRoleRevoke(c *RoleRevokeContext) + + // ExitRevokeProxy is called when exiting the revokeProxy production. + ExitRevokeProxy(c *RevokeProxyContext) + + // ExitSetPasswordStatement is called when exiting the setPasswordStatement production. + ExitSetPasswordStatement(c *SetPasswordStatementContext) + + // ExitUserSpecification is called when exiting the userSpecification production. + ExitUserSpecification(c *UserSpecificationContext) + + // ExitHashAuthOption is called when exiting the hashAuthOption production. + ExitHashAuthOption(c *HashAuthOptionContext) + + // ExitRandomAuthOption is called when exiting the randomAuthOption production. + ExitRandomAuthOption(c *RandomAuthOptionContext) + + // ExitStringAuthOption is called when exiting the stringAuthOption production. + ExitStringAuthOption(c *StringAuthOptionContext) + + // ExitModuleAuthOption is called when exiting the moduleAuthOption production. + ExitModuleAuthOption(c *ModuleAuthOptionContext) + + // ExitSimpleAuthOption is called when exiting the simpleAuthOption production. + ExitSimpleAuthOption(c *SimpleAuthOptionContext) + + // ExitAuthOptionClause is called when exiting the authOptionClause production. + ExitAuthOptionClause(c *AuthOptionClauseContext) + + // ExitModule is called when exiting the module production. + ExitModule(c *ModuleContext) + + // ExitPasswordModuleOption is called when exiting the passwordModuleOption production. + ExitPasswordModuleOption(c *PasswordModuleOptionContext) + + // ExitTlsOption is called when exiting the tlsOption production. + ExitTlsOption(c *TlsOptionContext) + + // ExitUserResourceOption is called when exiting the userResourceOption production. + ExitUserResourceOption(c *UserResourceOptionContext) + + // ExitUserPasswordOption is called when exiting the userPasswordOption production. + ExitUserPasswordOption(c *UserPasswordOptionContext) + + // ExitUserLockOption is called when exiting the userLockOption production. + ExitUserLockOption(c *UserLockOptionContext) + + // ExitPrivelegeClause is called when exiting the privelegeClause production. + ExitPrivelegeClause(c *PrivelegeClauseContext) + + // ExitPrivilege is called when exiting the privilege production. + ExitPrivilege(c *PrivilegeContext) + + // ExitCurrentSchemaPriviLevel is called when exiting the currentSchemaPriviLevel production. + ExitCurrentSchemaPriviLevel(c *CurrentSchemaPriviLevelContext) + + // ExitGlobalPrivLevel is called when exiting the globalPrivLevel production. + ExitGlobalPrivLevel(c *GlobalPrivLevelContext) + + // ExitDefiniteSchemaPrivLevel is called when exiting the definiteSchemaPrivLevel production. + ExitDefiniteSchemaPrivLevel(c *DefiniteSchemaPrivLevelContext) + + // ExitDefiniteFullTablePrivLevel is called when exiting the definiteFullTablePrivLevel production. + ExitDefiniteFullTablePrivLevel(c *DefiniteFullTablePrivLevelContext) + + // ExitDefiniteFullTablePrivLevel2 is called when exiting the definiteFullTablePrivLevel2 production. + ExitDefiniteFullTablePrivLevel2(c *DefiniteFullTablePrivLevel2Context) + + // ExitDefiniteTablePrivLevel is called when exiting the definiteTablePrivLevel production. + ExitDefiniteTablePrivLevel(c *DefiniteTablePrivLevelContext) + + // ExitRenameUserClause is called when exiting the renameUserClause production. + ExitRenameUserClause(c *RenameUserClauseContext) + + // ExitAnalyzeTable is called when exiting the analyzeTable production. + ExitAnalyzeTable(c *AnalyzeTableContext) + + // ExitCheckTable is called when exiting the checkTable production. + ExitCheckTable(c *CheckTableContext) + + // ExitChecksumTable is called when exiting the checksumTable production. + ExitChecksumTable(c *ChecksumTableContext) + + // ExitOptimizeTable is called when exiting the optimizeTable production. + ExitOptimizeTable(c *OptimizeTableContext) + + // ExitRepairTable is called when exiting the repairTable production. + ExitRepairTable(c *RepairTableContext) + + // ExitCheckTableOption is called when exiting the checkTableOption production. + ExitCheckTableOption(c *CheckTableOptionContext) + + // ExitCreateUdfunction is called when exiting the createUdfunction production. + ExitCreateUdfunction(c *CreateUdfunctionContext) + + // ExitInstallPlugin is called when exiting the installPlugin production. + ExitInstallPlugin(c *InstallPluginContext) + + // ExitUninstallPlugin is called when exiting the uninstallPlugin production. + ExitUninstallPlugin(c *UninstallPluginContext) + + // ExitSetVariable is called when exiting the setVariable production. + ExitSetVariable(c *SetVariableContext) + + // ExitSetCharset is called when exiting the setCharset production. + ExitSetCharset(c *SetCharsetContext) + + // ExitSetNames is called when exiting the setNames production. + ExitSetNames(c *SetNamesContext) + + // ExitSetPassword is called when exiting the setPassword production. + ExitSetPassword(c *SetPasswordContext) + + // ExitSetTransaction is called when exiting the setTransaction production. + ExitSetTransaction(c *SetTransactionContext) + + // ExitSetAutocommit is called when exiting the setAutocommit production. + ExitSetAutocommit(c *SetAutocommitContext) + + // ExitSetNewValueInsideTrigger is called when exiting the setNewValueInsideTrigger production. + ExitSetNewValueInsideTrigger(c *SetNewValueInsideTriggerContext) + + // ExitShowMasterLogs is called when exiting the showMasterLogs production. + ExitShowMasterLogs(c *ShowMasterLogsContext) + + // ExitShowLogEvents is called when exiting the showLogEvents production. + ExitShowLogEvents(c *ShowLogEventsContext) + + // ExitShowObjectFilter is called when exiting the showObjectFilter production. + ExitShowObjectFilter(c *ShowObjectFilterContext) + + // ExitShowColumns is called when exiting the showColumns production. + ExitShowColumns(c *ShowColumnsContext) + + // ExitShowCreateDb is called when exiting the showCreateDb production. + ExitShowCreateDb(c *ShowCreateDbContext) + + // ExitShowCreateFullIdObject is called when exiting the showCreateFullIdObject production. + ExitShowCreateFullIdObject(c *ShowCreateFullIdObjectContext) + + // ExitShowCreateUser is called when exiting the showCreateUser production. + ExitShowCreateUser(c *ShowCreateUserContext) + + // ExitShowEngine is called when exiting the showEngine production. + ExitShowEngine(c *ShowEngineContext) + + // ExitShowGlobalInfo is called when exiting the showGlobalInfo production. + ExitShowGlobalInfo(c *ShowGlobalInfoContext) + + // ExitShowErrors is called when exiting the showErrors production. + ExitShowErrors(c *ShowErrorsContext) + + // ExitShowCountErrors is called when exiting the showCountErrors production. + ExitShowCountErrors(c *ShowCountErrorsContext) + + // ExitShowSchemaFilter is called when exiting the showSchemaFilter production. + ExitShowSchemaFilter(c *ShowSchemaFilterContext) + + // ExitShowRoutine is called when exiting the showRoutine production. + ExitShowRoutine(c *ShowRoutineContext) + + // ExitShowGrants is called when exiting the showGrants production. + ExitShowGrants(c *ShowGrantsContext) + + // ExitShowIndexes is called when exiting the showIndexes production. + ExitShowIndexes(c *ShowIndexesContext) + + // ExitShowOpenTables is called when exiting the showOpenTables production. + ExitShowOpenTables(c *ShowOpenTablesContext) + + // ExitShowProfile is called when exiting the showProfile production. + ExitShowProfile(c *ShowProfileContext) + + // ExitShowSlaveStatus is called when exiting the showSlaveStatus production. + ExitShowSlaveStatus(c *ShowSlaveStatusContext) + + // ExitVariableClause is called when exiting the variableClause production. + ExitVariableClause(c *VariableClauseContext) + + // ExitShowCommonEntity is called when exiting the showCommonEntity production. + ExitShowCommonEntity(c *ShowCommonEntityContext) + + // ExitShowFilter is called when exiting the showFilter production. + ExitShowFilter(c *ShowFilterContext) + + // ExitShowGlobalInfoClause is called when exiting the showGlobalInfoClause production. + ExitShowGlobalInfoClause(c *ShowGlobalInfoClauseContext) + + // ExitShowSchemaEntity is called when exiting the showSchemaEntity production. + ExitShowSchemaEntity(c *ShowSchemaEntityContext) + + // ExitShowProfileType is called when exiting the showProfileType production. + ExitShowProfileType(c *ShowProfileTypeContext) + + // ExitBinlogStatement is called when exiting the binlogStatement production. + ExitBinlogStatement(c *BinlogStatementContext) + + // ExitCacheIndexStatement is called when exiting the cacheIndexStatement production. + ExitCacheIndexStatement(c *CacheIndexStatementContext) + + // ExitFlushStatement is called when exiting the flushStatement production. + ExitFlushStatement(c *FlushStatementContext) + + // ExitKillStatement is called when exiting the killStatement production. + ExitKillStatement(c *KillStatementContext) + + // ExitLoadIndexIntoCache is called when exiting the loadIndexIntoCache production. + ExitLoadIndexIntoCache(c *LoadIndexIntoCacheContext) + + // ExitResetStatement is called when exiting the resetStatement production. + ExitResetStatement(c *ResetStatementContext) + + // ExitShutdownStatement is called when exiting the shutdownStatement production. + ExitShutdownStatement(c *ShutdownStatementContext) + + // ExitTableIndexes is called when exiting the tableIndexes production. + ExitTableIndexes(c *TableIndexesContext) + + // ExitSimpleFlushOption is called when exiting the simpleFlushOption production. + ExitSimpleFlushOption(c *SimpleFlushOptionContext) + + // ExitChannelFlushOption is called when exiting the channelFlushOption production. + ExitChannelFlushOption(c *ChannelFlushOptionContext) + + // ExitTableFlushOption is called when exiting the tableFlushOption production. + ExitTableFlushOption(c *TableFlushOptionContext) + + // ExitFlushTableOption is called when exiting the flushTableOption production. + ExitFlushTableOption(c *FlushTableOptionContext) + + // ExitLoadedTableIndexes is called when exiting the loadedTableIndexes production. + ExitLoadedTableIndexes(c *LoadedTableIndexesContext) + + // ExitSimpleDescribeStatement is called when exiting the simpleDescribeStatement production. + ExitSimpleDescribeStatement(c *SimpleDescribeStatementContext) + + // ExitFullDescribeStatement is called when exiting the fullDescribeStatement production. + ExitFullDescribeStatement(c *FullDescribeStatementContext) + + // ExitHelpStatement is called when exiting the helpStatement production. + ExitHelpStatement(c *HelpStatementContext) + + // ExitUseStatement is called when exiting the useStatement production. + ExitUseStatement(c *UseStatementContext) + + // ExitSignalStatement is called when exiting the signalStatement production. + ExitSignalStatement(c *SignalStatementContext) + + // ExitResignalStatement is called when exiting the resignalStatement production. + ExitResignalStatement(c *ResignalStatementContext) + + // ExitSignalConditionInformation is called when exiting the signalConditionInformation production. + ExitSignalConditionInformation(c *SignalConditionInformationContext) + + // ExitWithStatement is called when exiting the withStatement production. + ExitWithStatement(c *WithStatementContext) + + // ExitTableStatement is called when exiting the tableStatement production. + ExitTableStatement(c *TableStatementContext) + + // ExitDiagnosticsStatement is called when exiting the diagnosticsStatement production. + ExitDiagnosticsStatement(c *DiagnosticsStatementContext) + + // ExitDiagnosticsConditionInformationName is called when exiting the diagnosticsConditionInformationName production. + ExitDiagnosticsConditionInformationName(c *DiagnosticsConditionInformationNameContext) + + // ExitDescribeStatements is called when exiting the describeStatements production. + ExitDescribeStatements(c *DescribeStatementsContext) + + // ExitDescribeConnection is called when exiting the describeConnection production. + ExitDescribeConnection(c *DescribeConnectionContext) + + // ExitFullId is called when exiting the fullId production. + ExitFullId(c *FullIdContext) + + // ExitTableName is called when exiting the tableName production. + ExitTableName(c *TableNameContext) + + // ExitRoleName is called when exiting the roleName production. + ExitRoleName(c *RoleNameContext) + + // ExitFullColumnName is called when exiting the fullColumnName production. + ExitFullColumnName(c *FullColumnNameContext) + + // ExitIndexColumnName is called when exiting the indexColumnName production. + ExitIndexColumnName(c *IndexColumnNameContext) + + // ExitSimpleUserName is called when exiting the simpleUserName production. + ExitSimpleUserName(c *SimpleUserNameContext) + + // ExitHostName is called when exiting the hostName production. + ExitHostName(c *HostNameContext) + + // ExitUserName is called when exiting the userName production. + ExitUserName(c *UserNameContext) + + // ExitMysqlVariable is called when exiting the mysqlVariable production. + ExitMysqlVariable(c *MysqlVariableContext) + + // ExitCharsetName is called when exiting the charsetName production. + ExitCharsetName(c *CharsetNameContext) + + // ExitCollationName is called when exiting the collationName production. + ExitCollationName(c *CollationNameContext) + + // ExitEngineName is called when exiting the engineName production. + ExitEngineName(c *EngineNameContext) + + // ExitEngineNameBase is called when exiting the engineNameBase production. + ExitEngineNameBase(c *EngineNameBaseContext) + + // ExitUuidSet is called when exiting the uuidSet production. + ExitUuidSet(c *UuidSetContext) + + // ExitXid is called when exiting the xid production. + ExitXid(c *XidContext) + + // ExitXuidStringId is called when exiting the xuidStringId production. + ExitXuidStringId(c *XuidStringIdContext) + + // ExitAuthPlugin is called when exiting the authPlugin production. + ExitAuthPlugin(c *AuthPluginContext) + + // ExitUid is called when exiting the uid production. + ExitUid(c *UidContext) + + // ExitSimpleId is called when exiting the simpleId production. + ExitSimpleId(c *SimpleIdContext) + + // ExitDottedId is called when exiting the dottedId production. + ExitDottedId(c *DottedIdContext) + + // ExitDecimalLiteral is called when exiting the decimalLiteral production. + ExitDecimalLiteral(c *DecimalLiteralContext) + + // ExitFileSizeLiteral is called when exiting the fileSizeLiteral production. + ExitFileSizeLiteral(c *FileSizeLiteralContext) + + // ExitStringLiteral is called when exiting the stringLiteral production. + ExitStringLiteral(c *StringLiteralContext) + + // ExitBooleanLiteral is called when exiting the booleanLiteral production. + ExitBooleanLiteral(c *BooleanLiteralContext) + + // ExitHexadecimalLiteral is called when exiting the hexadecimalLiteral production. + ExitHexadecimalLiteral(c *HexadecimalLiteralContext) + + // ExitNullNotnull is called when exiting the nullNotnull production. + ExitNullNotnull(c *NullNotnullContext) + + // ExitConstant is called when exiting the constant production. + ExitConstant(c *ConstantContext) + + // ExitStringDataType is called when exiting the stringDataType production. + ExitStringDataType(c *StringDataTypeContext) + + // ExitNationalVaryingStringDataType is called when exiting the nationalVaryingStringDataType production. + ExitNationalVaryingStringDataType(c *NationalVaryingStringDataTypeContext) + + // ExitNationalStringDataType is called when exiting the nationalStringDataType production. + ExitNationalStringDataType(c *NationalStringDataTypeContext) + + // ExitDimensionDataType is called when exiting the dimensionDataType production. + ExitDimensionDataType(c *DimensionDataTypeContext) + + // ExitSimpleDataType is called when exiting the simpleDataType production. + ExitSimpleDataType(c *SimpleDataTypeContext) + + // ExitCollectionDataType is called when exiting the collectionDataType production. + ExitCollectionDataType(c *CollectionDataTypeContext) + + // ExitSpatialDataType is called when exiting the spatialDataType production. + ExitSpatialDataType(c *SpatialDataTypeContext) + + // ExitLongVarcharDataType is called when exiting the longVarcharDataType production. + ExitLongVarcharDataType(c *LongVarcharDataTypeContext) + + // ExitLongVarbinaryDataType is called when exiting the longVarbinaryDataType production. + ExitLongVarbinaryDataType(c *LongVarbinaryDataTypeContext) + + // ExitCollectionOptions is called when exiting the collectionOptions production. + ExitCollectionOptions(c *CollectionOptionsContext) + + // ExitConvertedDataType is called when exiting the convertedDataType production. + ExitConvertedDataType(c *ConvertedDataTypeContext) + + // ExitLengthOneDimension is called when exiting the lengthOneDimension production. + ExitLengthOneDimension(c *LengthOneDimensionContext) + + // ExitLengthTwoDimension is called when exiting the lengthTwoDimension production. + ExitLengthTwoDimension(c *LengthTwoDimensionContext) + + // ExitLengthTwoOptionalDimension is called when exiting the lengthTwoOptionalDimension production. + ExitLengthTwoOptionalDimension(c *LengthTwoOptionalDimensionContext) + + // ExitUidList is called when exiting the uidList production. + ExitUidList(c *UidListContext) + + // ExitFullColumnNameList is called when exiting the fullColumnNameList production. + ExitFullColumnNameList(c *FullColumnNameListContext) + + // ExitTables is called when exiting the tables production. + ExitTables(c *TablesContext) + + // ExitIndexColumnNames is called when exiting the indexColumnNames production. + ExitIndexColumnNames(c *IndexColumnNamesContext) + + // ExitExpressions is called when exiting the expressions production. + ExitExpressions(c *ExpressionsContext) + + // ExitExpressionsWithDefaults is called when exiting the expressionsWithDefaults production. + ExitExpressionsWithDefaults(c *ExpressionsWithDefaultsContext) + + // ExitConstants is called when exiting the constants production. + ExitConstants(c *ConstantsContext) + + // ExitSimpleStrings is called when exiting the simpleStrings production. + ExitSimpleStrings(c *SimpleStringsContext) + + // ExitUserVariables is called when exiting the userVariables production. + ExitUserVariables(c *UserVariablesContext) + + // ExitDefaultValue is called when exiting the defaultValue production. + ExitDefaultValue(c *DefaultValueContext) + + // ExitCurrentTimestamp is called when exiting the currentTimestamp production. + ExitCurrentTimestamp(c *CurrentTimestampContext) + + // ExitExpressionOrDefault is called when exiting the expressionOrDefault production. + ExitExpressionOrDefault(c *ExpressionOrDefaultContext) + + // ExitIfExists is called when exiting the ifExists production. + ExitIfExists(c *IfExistsContext) + + // ExitIfNotExists is called when exiting the ifNotExists production. + ExitIfNotExists(c *IfNotExistsContext) + + // ExitOrReplace is called when exiting the orReplace production. + ExitOrReplace(c *OrReplaceContext) + + // ExitWaitNowaitClause is called when exiting the waitNowaitClause production. + ExitWaitNowaitClause(c *WaitNowaitClauseContext) + + // ExitSpecificFunctionCall is called when exiting the specificFunctionCall production. + ExitSpecificFunctionCall(c *SpecificFunctionCallContext) + + // ExitAggregateFunctionCall is called when exiting the aggregateFunctionCall production. + ExitAggregateFunctionCall(c *AggregateFunctionCallContext) + + // ExitNonAggregateFunctionCall is called when exiting the nonAggregateFunctionCall production. + ExitNonAggregateFunctionCall(c *NonAggregateFunctionCallContext) + + // ExitScalarFunctionCall is called when exiting the scalarFunctionCall production. + ExitScalarFunctionCall(c *ScalarFunctionCallContext) + + // ExitUdfFunctionCall is called when exiting the udfFunctionCall production. + ExitUdfFunctionCall(c *UdfFunctionCallContext) + + // ExitPasswordFunctionCall is called when exiting the passwordFunctionCall production. + ExitPasswordFunctionCall(c *PasswordFunctionCallContext) + + // ExitSimpleFunctionCall is called when exiting the simpleFunctionCall production. + ExitSimpleFunctionCall(c *SimpleFunctionCallContext) + + // ExitCurrentUser is called when exiting the currentUser production. + ExitCurrentUser(c *CurrentUserContext) + + // ExitDataTypeFunctionCall is called when exiting the dataTypeFunctionCall production. + ExitDataTypeFunctionCall(c *DataTypeFunctionCallContext) + + // ExitValuesFunctionCall is called when exiting the valuesFunctionCall production. + ExitValuesFunctionCall(c *ValuesFunctionCallContext) + + // ExitCaseExpressionFunctionCall is called when exiting the caseExpressionFunctionCall production. + ExitCaseExpressionFunctionCall(c *CaseExpressionFunctionCallContext) + + // ExitCaseFunctionCall is called when exiting the caseFunctionCall production. + ExitCaseFunctionCall(c *CaseFunctionCallContext) + + // ExitCharFunctionCall is called when exiting the charFunctionCall production. + ExitCharFunctionCall(c *CharFunctionCallContext) + + // ExitPositionFunctionCall is called when exiting the positionFunctionCall production. + ExitPositionFunctionCall(c *PositionFunctionCallContext) + + // ExitSubstrFunctionCall is called when exiting the substrFunctionCall production. + ExitSubstrFunctionCall(c *SubstrFunctionCallContext) + + // ExitTrimFunctionCall is called when exiting the trimFunctionCall production. + ExitTrimFunctionCall(c *TrimFunctionCallContext) + + // ExitWeightFunctionCall is called when exiting the weightFunctionCall production. + ExitWeightFunctionCall(c *WeightFunctionCallContext) + + // ExitExtractFunctionCall is called when exiting the extractFunctionCall production. + ExitExtractFunctionCall(c *ExtractFunctionCallContext) + + // ExitGetFormatFunctionCall is called when exiting the getFormatFunctionCall production. + ExitGetFormatFunctionCall(c *GetFormatFunctionCallContext) + + // ExitJsonValueFunctionCall is called when exiting the jsonValueFunctionCall production. + ExitJsonValueFunctionCall(c *JsonValueFunctionCallContext) + + // ExitCaseFuncAlternative is called when exiting the caseFuncAlternative production. + ExitCaseFuncAlternative(c *CaseFuncAlternativeContext) + + // ExitLevelWeightList is called when exiting the levelWeightList production. + ExitLevelWeightList(c *LevelWeightListContext) + + // ExitLevelWeightRange is called when exiting the levelWeightRange production. + ExitLevelWeightRange(c *LevelWeightRangeContext) + + // ExitLevelInWeightListElement is called when exiting the levelInWeightListElement production. + ExitLevelInWeightListElement(c *LevelInWeightListElementContext) + + // ExitAggregateWindowedFunction is called when exiting the aggregateWindowedFunction production. + ExitAggregateWindowedFunction(c *AggregateWindowedFunctionContext) + + // ExitNonAggregateWindowedFunction is called when exiting the nonAggregateWindowedFunction production. + ExitNonAggregateWindowedFunction(c *NonAggregateWindowedFunctionContext) + + // ExitOverClause is called when exiting the overClause production. + ExitOverClause(c *OverClauseContext) + + // ExitWindowSpec is called when exiting the windowSpec production. + ExitWindowSpec(c *WindowSpecContext) + + // ExitWindowName is called when exiting the windowName production. + ExitWindowName(c *WindowNameContext) + + // ExitFrameClause is called when exiting the frameClause production. + ExitFrameClause(c *FrameClauseContext) + + // ExitFrameUnits is called when exiting the frameUnits production. + ExitFrameUnits(c *FrameUnitsContext) + + // ExitFrameExtent is called when exiting the frameExtent production. + ExitFrameExtent(c *FrameExtentContext) + + // ExitFrameBetween is called when exiting the frameBetween production. + ExitFrameBetween(c *FrameBetweenContext) + + // ExitFrameRange is called when exiting the frameRange production. + ExitFrameRange(c *FrameRangeContext) + + // ExitPartitionClause is called when exiting the partitionClause production. + ExitPartitionClause(c *PartitionClauseContext) + + // ExitScalarFunctionName is called when exiting the scalarFunctionName production. + ExitScalarFunctionName(c *ScalarFunctionNameContext) + + // ExitPasswordFunctionClause is called when exiting the passwordFunctionClause production. + ExitPasswordFunctionClause(c *PasswordFunctionClauseContext) + + // ExitFunctionArgs is called when exiting the functionArgs production. + ExitFunctionArgs(c *FunctionArgsContext) + + // ExitFunctionArg is called when exiting the functionArg production. + ExitFunctionArg(c *FunctionArgContext) + + // ExitIsExpression is called when exiting the isExpression production. + ExitIsExpression(c *IsExpressionContext) + + // ExitNotExpression is called when exiting the notExpression production. + ExitNotExpression(c *NotExpressionContext) + + // ExitLogicalExpression is called when exiting the logicalExpression production. + ExitLogicalExpression(c *LogicalExpressionContext) + + // ExitPredicateExpression is called when exiting the predicateExpression production. + ExitPredicateExpression(c *PredicateExpressionContext) + + // ExitSoundsLikePredicate is called when exiting the soundsLikePredicate production. + ExitSoundsLikePredicate(c *SoundsLikePredicateContext) + + // ExitExpressionAtomPredicate is called when exiting the expressionAtomPredicate production. + ExitExpressionAtomPredicate(c *ExpressionAtomPredicateContext) + + // ExitSubqueryComparisonPredicate is called when exiting the subqueryComparisonPredicate production. + ExitSubqueryComparisonPredicate(c *SubqueryComparisonPredicateContext) + + // ExitJsonMemberOfPredicate is called when exiting the jsonMemberOfPredicate production. + ExitJsonMemberOfPredicate(c *JsonMemberOfPredicateContext) + + // ExitBinaryComparisonPredicate is called when exiting the binaryComparisonPredicate production. + ExitBinaryComparisonPredicate(c *BinaryComparisonPredicateContext) + + // ExitInPredicate is called when exiting the inPredicate production. + ExitInPredicate(c *InPredicateContext) + + // ExitBetweenPredicate is called when exiting the betweenPredicate production. + ExitBetweenPredicate(c *BetweenPredicateContext) + + // ExitIsNullPredicate is called when exiting the isNullPredicate production. + ExitIsNullPredicate(c *IsNullPredicateContext) + + // ExitLikePredicate is called when exiting the likePredicate production. + ExitLikePredicate(c *LikePredicateContext) + + // ExitRegexpPredicate is called when exiting the regexpPredicate production. + ExitRegexpPredicate(c *RegexpPredicateContext) + + // ExitUnaryExpressionAtom is called when exiting the unaryExpressionAtom production. + ExitUnaryExpressionAtom(c *UnaryExpressionAtomContext) + + // ExitCollateExpressionAtom is called when exiting the collateExpressionAtom production. + ExitCollateExpressionAtom(c *CollateExpressionAtomContext) + + // ExitVariableAssignExpressionAtom is called when exiting the variableAssignExpressionAtom production. + ExitVariableAssignExpressionAtom(c *VariableAssignExpressionAtomContext) + + // ExitMysqlVariableExpressionAtom is called when exiting the mysqlVariableExpressionAtom production. + ExitMysqlVariableExpressionAtom(c *MysqlVariableExpressionAtomContext) + + // ExitNestedExpressionAtom is called when exiting the nestedExpressionAtom production. + ExitNestedExpressionAtom(c *NestedExpressionAtomContext) + + // ExitNestedRowExpressionAtom is called when exiting the nestedRowExpressionAtom production. + ExitNestedRowExpressionAtom(c *NestedRowExpressionAtomContext) + + // ExitMathExpressionAtom is called when exiting the mathExpressionAtom production. + ExitMathExpressionAtom(c *MathExpressionAtomContext) + + // ExitExistsExpressionAtom is called when exiting the existsExpressionAtom production. + ExitExistsExpressionAtom(c *ExistsExpressionAtomContext) + + // ExitIntervalExpressionAtom is called when exiting the intervalExpressionAtom production. + ExitIntervalExpressionAtom(c *IntervalExpressionAtomContext) + + // ExitJsonExpressionAtom is called when exiting the jsonExpressionAtom production. + ExitJsonExpressionAtom(c *JsonExpressionAtomContext) + + // ExitSubqueryExpressionAtom is called when exiting the subqueryExpressionAtom production. + ExitSubqueryExpressionAtom(c *SubqueryExpressionAtomContext) + + // ExitConstantExpressionAtom is called when exiting the constantExpressionAtom production. + ExitConstantExpressionAtom(c *ConstantExpressionAtomContext) + + // ExitFunctionCallExpressionAtom is called when exiting the functionCallExpressionAtom production. + ExitFunctionCallExpressionAtom(c *FunctionCallExpressionAtomContext) + + // ExitBinaryExpressionAtom is called when exiting the binaryExpressionAtom production. + ExitBinaryExpressionAtom(c *BinaryExpressionAtomContext) + + // ExitFullColumnNameExpressionAtom is called when exiting the fullColumnNameExpressionAtom production. + ExitFullColumnNameExpressionAtom(c *FullColumnNameExpressionAtomContext) + + // ExitBitExpressionAtom is called when exiting the bitExpressionAtom production. + ExitBitExpressionAtom(c *BitExpressionAtomContext) + + // ExitUnaryOperator is called when exiting the unaryOperator production. + ExitUnaryOperator(c *UnaryOperatorContext) + + // ExitComparisonOperator is called when exiting the comparisonOperator production. + ExitComparisonOperator(c *ComparisonOperatorContext) + + // ExitLogicalOperator is called when exiting the logicalOperator production. + ExitLogicalOperator(c *LogicalOperatorContext) + + // ExitBitOperator is called when exiting the bitOperator production. + ExitBitOperator(c *BitOperatorContext) + + // ExitMultOperator is called when exiting the multOperator production. + ExitMultOperator(c *MultOperatorContext) + + // ExitAddOperator is called when exiting the addOperator production. + ExitAddOperator(c *AddOperatorContext) + + // ExitJsonOperator is called when exiting the jsonOperator production. + ExitJsonOperator(c *JsonOperatorContext) + + // ExitCharsetNameBase is called when exiting the charsetNameBase production. + ExitCharsetNameBase(c *CharsetNameBaseContext) + + // ExitTransactionLevelBase is called when exiting the transactionLevelBase production. + ExitTransactionLevelBase(c *TransactionLevelBaseContext) + + // ExitPrivilegesBase is called when exiting the privilegesBase production. + ExitPrivilegesBase(c *PrivilegesBaseContext) + + // ExitIntervalTypeBase is called when exiting the intervalTypeBase production. + ExitIntervalTypeBase(c *IntervalTypeBaseContext) + + // ExitDataTypeBase is called when exiting the dataTypeBase production. + ExitDataTypeBase(c *DataTypeBaseContext) + + // ExitKeywordsCanBeId is called when exiting the keywordsCanBeId production. + ExitKeywordsCanBeId(c *KeywordsCanBeIdContext) + + // ExitFunctionNameBase is called when exiting the functionNameBase production. + ExitFunctionNameBase(c *FunctionNameBaseContext) +}