// Code generated from MySqlParser.g4 by ANTLR 4.13.1. DO NOT EDIT.

package parser // 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'", "'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'", "'ELT'", "'ENCODE'", "'ENCRYPT'", "'ENDPOINT'", "'ENGINE_ATTRIBUTE'",
		"'ENVELOPE'", "'EQUALS'", "'EXP'", "'EXPORT_SET'", "'EXTERIORRING'",
		"'EXTRACTVALUE'", "'FIELD'", "'FIND_IN_SET'", "'FLOOR'", "'FORMAT'",
		"'FOUND_ROWS'", "'FROM_BASE64'", "'FROM_DAYS'", "'FROM_UNIXTIME'", "'GEOMCOLLFROMTEXT'",
		"'GEOMCOLLFROMWKB'", "'GEOMETRYCOLLECTIONFROMTEXT'", "'GEOMETRYCOLLECTIONFROMWKB'",
		"'GEOMETRYFROMTEXT'", "'GEOMETRYFROMWKB'", "'GEOMETRYN'", "'GEOMETRYTYPE'",
		"'GEOMFROMTEXT'", "'GEOMFROMWKB'", "'GET_FORMAT'", "'GET_LOCK'", "'GLENGTH'",
		"'GREATEST'", "'GTID_SUBSET'", "'GTID_SUBTRACT'", "'HEX'", "'IFNULL'",
		"'INET6_ATON'", "'INET6_NTOA'", "'INET_ATON'", "'INET_NTOA'", "'INSTR'",
		"'INTERIORRINGN'", "'INTERSECTS'", "'ISCLOSED'", "'ISEMPTY'", "'ISNULL'",
		"'ISSIMPLE'", "'IS_FREE_LOCK'", "'IS_IPV4'", "'IS_IPV4_COMPAT'", "'IS_IPV4_MAPPED'",
		"'IS_IPV6'", "'IS_USED_LOCK'", "'LAST_INSERT_ID'", "'LCASE'", "'LEAST'",
		"'LENGTH'", "'LINEFROMTEXT'", "'LINEFROMWKB'", "'LINESTRINGFROMTEXT'",
		"'LINESTRINGFROMWKB'", "'LN'", "'LOAD_FILE'", "'LOCATE'", "'LOG'", "'LOG10'",
		"'LOG2'", "'LOWER'", "'LPAD'", "'LTRIM'", "'MAKEDATE'", "'MAKETIME'",
		"'MAKE_SET'", "'MASTER_POS_WAIT'", "'MBRCONTAINS'", "'MBRDISJOINT'",
		"'MBREQUAL'", "'MBRINTERSECTS'", "'MBROVERLAPS'", "'MBRTOUCHES'", "'MBRWITHIN'",
		"'MD5'", "'MLINEFROMTEXT'", "'MLINEFROMWKB'", "'MONTHNAME'", "'MPOINTFROMTEXT'",
		"'MPOINTFROMWKB'", "'MPOLYFROMTEXT'", "'MPOLYFROMWKB'", "'MULTILINESTRINGFROMTEXT'",
		"'MULTILINESTRINGFROMWKB'", "'MULTIPOINTFROMTEXT'", "'MULTIPOINTFROMWKB'",
		"'MULTIPOLYGONFROMTEXT'", "'MULTIPOLYGONFROMWKB'", "'NAME_CONST'", "'NULLIF'",
		"'NUMGEOMETRIES'", "'NUMINTERIORRINGS'", "'NUMPOINTS'", "'OCT'", "'OCTET_LENGTH'",
		"'ORD'", "'OVERLAPS'", "'PERIOD_ADD'", "'PERIOD_DIFF'", "'PI'", "'POINTFROMTEXT'",
		"'POINTFROMWKB'", "'POINTN'", "'POLYFROMTEXT'", "'POLYFROMWKB'", "'POLYGONFROMTEXT'",
		"'POLYGONFROMWKB'", "'POW'", "'POWER'", "'QUOTE'", "'RADIANS'", "'RAND'",
		"'RANDOM'", "'RANDOM_BYTES'", "'RELEASE_LOCK'", "'REVERSE'", "'ROUND'",
		"'ROW_COUNT'", "'RPAD'", "'RTRIM'", "'SEC_TO_TIME'", "'SECONDARY_ENGINE_ATTRIBUTE'",
		"'SESSION_USER'", "'SHA'", "'SHA1'", "'SHA2'", "'SCHEMA_NAME'", "'SIGN'",
		"'SIN'", "'SLEEP'", "'SOUNDEX'", "'SQL_THREAD_WAIT_AFTER_GTIDS'", "'SQRT'",
		"'SRID'", "'STARTPOINT'", "'STRCMP'", "'STR_TO_DATE'", "'ST_AREA'",
		"'ST_ASBINARY'", "'ST_ASTEXT'", "'ST_ASWKB'", "'ST_ASWKT'", "'ST_BUFFER'",
		"'ST_CENTROID'", "'ST_CONTAINS'", "'ST_CROSSES'", "'ST_DIFFERENCE'",
		"'ST_DIMENSION'", "'ST_DISJOINT'", "'ST_DISTANCE'", "'ST_ENDPOINT'",
		"'ST_ENVELOPE'", "'ST_EQUALS'", "'ST_EXTERIORRING'", "'ST_GEOMCOLLFROMTEXT'",
		"'ST_GEOMCOLLFROMTXT'", "'ST_GEOMCOLLFROMWKB'", "'ST_GEOMETRYCOLLECTIONFROMTEXT'",
		"'ST_GEOMETRYCOLLECTIONFROMWKB'", "'ST_GEOMETRYFROMTEXT'", "'ST_GEOMETRYFROMWKB'",
		"'ST_GEOMETRYN'", "'ST_GEOMETRYTYPE'", "'ST_GEOMFROMTEXT'", "'ST_GEOMFROMWKB'",
		"'ST_INTERIORRINGN'", "'ST_INTERSECTION'", "'ST_INTERSECTS'", "'ST_ISCLOSED'",
		"'ST_ISEMPTY'", "'ST_ISSIMPLE'", "'ST_LINEFROMTEXT'", "'ST_LINEFROMWKB'",
		"'ST_LINESTRINGFROMTEXT'", "'ST_LINESTRINGFROMWKB'", "'ST_NUMGEOMETRIES'",
		"'ST_NUMINTERIORRING'", "'ST_NUMINTERIORRINGS'", "'ST_NUMPOINTS'", "'ST_OVERLAPS'",
		"'ST_POINTFROMTEXT'", "'ST_POINTFROMWKB'", "'ST_POINTN'", "'ST_POLYFROMTEXT'",
		"'ST_POLYFROMWKB'", "'ST_POLYGONFROMTEXT'", "'ST_POLYGONFROMWKB'", "'ST_SRID'",
		"'ST_STARTPOINT'", "'ST_SYMDIFFERENCE'", "'ST_TOUCHES'", "'ST_UNION'",
		"'ST_WITHIN'", "'ST_X'", "'ST_Y'", "'SUBDATE'", "'SUBSTRING_INDEX'",
		"'SUBTIME'", "'SYSTEM_USER'", "'TAN'", "'TIMEDIFF'", "'TIMESTAMPADD'",
		"'TIMESTAMPDIFF'", "'TIME_FORMAT'", "'TIME_TO_SEC'", "'TOUCHES'", "'TO_BASE64'",
		"'TO_DAYS'", "'TO_SECONDS'", "'TP_CONNECTION_ADMIN'", "'UCASE'", "'UNCOMPRESS'",
		"'UNCOMPRESSED_LENGTH'", "'UNHEX'", "'UNIX_TIMESTAMP'", "'UPDATEXML'",
		"'UPPER'", "'UUID'", "'UUID_SHORT'", "'VALIDATE_PASSWORD_STRENGTH'",
		"'VERSION'", "'WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS'", "'WEEKDAY'", "'WEEKOFYEAR'",
		"'WEIGHT_STRING'", "'WITHIN'", "'YEARWEEK'", "'Y'", "'X'", "':='", "'+='",
		"'-='", "'*='", "'/='", "'%='", "'&='", "'^='", "'|='", "'*'", "'/'",
		"'%'", "'+'", "'-'", "'DIV'", "'MOD'", "'='", "'>'", "'<'", "'!'", "'~'",
		"'|'", "'&'", "'^'", "'.'", "'('", "')'", "','", "';'", "'@'", "'0'",
		"'1'", "'2'", "'''", "'\"'", "'`'", "':'",
	}
	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",
		"YEAR_MONTH", "DAY_HOUR", "DAY_MINUTE", "DAY_SECOND", "HOUR_MINUTE",
		"HOUR_SECOND", "MINUTE_SECOND", "SECOND_MICROSECOND", "MINUTE_MICROSECOND",
		"HOUR_MICROSECOND", "DAY_MICROSECOND", "JSON_ARRAY", "JSON_ARRAYAGG",
		"JSON_ARRAY_APPEND", "JSON_ARRAY_INSERT", "JSON_CONTAINS", "JSON_CONTAINS_PATH",
		"JSON_DEPTH", "JSON_EXTRACT", "JSON_INSERT", "JSON_KEYS", "JSON_LENGTH",
		"JSON_MERGE", "JSON_MERGE_PATCH", "JSON_MERGE_PRESERVE", "JSON_OBJECT",
		"JSON_OBJECTAGG", "JSON_OVERLAPS", "JSON_PRETTY", "JSON_QUOTE", "JSON_REMOVE",
		"JSON_REPLACE", "JSON_SCHEMA_VALID", "JSON_SCHEMA_VALIDATION_REPORT",
		"JSON_SEARCH", "JSON_SET", "JSON_STORAGE_FREE", "JSON_STORAGE_SIZE",
		"JSON_TABLE", "JSON_TYPE", "JSON_UNQUOTE", "JSON_VALID", "JSON_VALUE",
		"NESTED", "ORDINALITY", "PATH", "AVG", "BIT_AND", "BIT_OR", "BIT_XOR",
		"COUNT", "CUME_DIST", "DENSE_RANK", "FIRST_VALUE", "GROUP_CONCAT", "LAG",
		"LAST_VALUE", "LEAD", "MAX", "MIN", "NTILE", "NTH_VALUE", "PERCENT_RANK",
		"RANK", "ROW_NUMBER", "STD", "STDDEV", "STDDEV_POP", "STDDEV_SAMP",
		"SUM", "VAR_POP", "VAR_SAMP", "VARIANCE", "CURRENT_DATE", "CURRENT_TIME",
		"CURRENT_TIMESTAMP", "LOCALTIME", "CURDATE", "CURTIME", "DATE_ADD",
		"DATE_SUB", "EXTRACT", "LOCALTIMESTAMP", "NOW", "POSITION", "SUBSTR",
		"SUBSTRING", "SYSDATE", "TRIM", "UTC_DATE", "UTC_TIME", "UTC_TIMESTAMP",
		"ACCOUNT", "ACTION", "AFTER", "AGGREGATE", "ALGORITHM", "ANY", "AT",
		"AUTHORS", "AUTOCOMMIT", "AUTOEXTEND_SIZE", "AUTO_INCREMENT", "AVG_ROW_LENGTH",
		"BEGIN", "BINLOG", "BIT", "BLOCK", "BOOL", "BOOLEAN", "BTREE", "CACHE",
		"CASCADED", "CHAIN", "CHANGED", "CHANNEL", "CHECKSUM", "PAGE_CHECKSUM",
		"CIPHER", "CLASS_ORIGIN", "CLIENT", "CLOSE", "CLUSTERING", "COALESCE",
		"CODE", "COLUMNS", "COLUMN_FORMAT", "COLUMN_NAME", "COMMENT", "COMMIT",
		"COMPACT", "COMPLETION", "COMPRESSED", "COMPRESSION", "CONCURRENT",
		"CONNECT", "CONNECTION", "CONSISTENT", "CONSTRAINT_CATALOG", "CONSTRAINT_SCHEMA",
		"CONSTRAINT_NAME", "CONTAINS", "CONTEXT", "CONTRIBUTORS", "COPY", "CPU",
		"CYCLE", "CURSOR_NAME", "DATA", "DATAFILE", "DEALLOCATE", "DEFAULT_AUTH",
		"DEFINER", "DELAY_KEY_WRITE", "DES_KEY_FILE", "DIRECTORY", "DISABLE",
		"DISCARD", "DISK", "DO", "DUMPFILE", "DUPLICATE", "DYNAMIC", "ENABLE",
		"ENCRYPTED", "ENCRYPTION", "ENCRYPTION_KEY_ID", "END", "ENDS", "ENGINE",
		"ENGINES", "ERROR", "ERRORS", "ESCAPE", "EVEN", "EVENT", "EVENTS", "EVERY",
		"EXCHANGE", "EXCLUSIVE", "EXPIRE", "EXPORT", "EXTENDED", "EXTENT_SIZE",
		"FAILED_LOGIN_ATTEMPTS", "FAST", "FAULTS", "FIELDS", "FILE_BLOCK_SIZE",
		"FILTER", "FIRST", "FIXED", "FLUSH", "FOLLOWING", "FOLLOWS", "FOUND",
		"FULL", "FUNCTION", "GENERAL", "GLOBAL", "GRANTS", "GROUP_REPLICATION",
		"HANDLER", "HASH", "HELP", "HISTORY", "HOST", "HOSTS", "IDENTIFIED",
		"IGNORE_SERVER_IDS", "IMPORT", "INCREMENT", "INDEXES", "INITIAL_SIZE",
		"INPLACE", "INSERT_METHOD", "INSTALL", "INSTANCE", "INSTANT", "INVISIBLE",
		"INVOKER", "IO", "IO_THREAD", "IPC", "ISOLATION", "ISSUER", "JSON",
		"KEY_BLOCK_SIZE", "LANGUAGE", "LAST", "LEAVES", "LESS", "LEVEL", "LIST",
		"LOCAL", "LOGFILE", "LOGS", "MASTER", "MASTER_AUTO_POSITION", "MASTER_CONNECT_RETRY",
		"MASTER_DELAY", "MASTER_HEARTBEAT_PERIOD", "MASTER_HOST", "MASTER_LOG_FILE",
		"MASTER_LOG_POS", "MASTER_PASSWORD", "MASTER_PORT", "MASTER_RETRY_COUNT",
		"MASTER_SSL", "MASTER_SSL_CA", "MASTER_SSL_CAPATH", "MASTER_SSL_CERT",
		"MASTER_SSL_CIPHER", "MASTER_SSL_CRL", "MASTER_SSL_CRLPATH", "MASTER_SSL_KEY",
		"MASTER_TLS_VERSION", "MASTER_USER", "MAX_CONNECTIONS_PER_HOUR", "MAX_QUERIES_PER_HOUR",
		"MAX_ROWS", "MAX_SIZE", "MAX_UPDATES_PER_HOUR", "MAX_USER_CONNECTIONS",
		"MEDIUM", "MEMBER", "MERGE", "MESSAGE_TEXT", "MID", "MIGRATE", "MIN_ROWS",
		"MODE", "MODIFY", "MUTEX", "MYSQL", "MYSQL_ERRNO", "NAME", "NAMES",
		"NCHAR", "NEVER", "NEXT", "NO", "NOCACHE", "NOCOPY", "NOCYCLE", "NOMAXVALUE",
		"NOMINVALUE", "NOWAIT", "NODEGROUP", "NONE", "ODBC", "OFFLINE", "OFFSET",
		"OF", "OJ", "OLD_PASSWORD", "ONE", "ONLINE", "ONLY", "OPEN", "OPTIMIZER_COSTS",
		"OPTIONS", "OWNER", "PACK_KEYS", "PAGE", "PAGE_COMPRESSED", "PAGE_COMPRESSION_LEVEL",
		"PARSER", "PARTIAL", "PARTITIONING", "PARTITIONS", "PASSWORD", "PASSWORD_LOCK_TIME",
		"PHASE", "PLUGIN", "PLUGIN_DIR", "PLUGINS", "PORT", "PRECEDES", "PRECEDING",
		"PREPARE", "PRESERVE", "PREV", "PROCESSLIST", "PROFILE", "PROFILES",
		"PROXY", "QUERY", "QUICK", "REBUILD", "RECOVER", "RECURSIVE", "REDO_BUFFER_SIZE",
		"REDUNDANT", "RELAY", "RELAY_LOG_FILE", "RELAY_LOG_POS", "RELAYLOG",
		"REMOVE", "REORGANIZE", "REPAIR", "REPLICATE_DO_DB", "REPLICATE_DO_TABLE",
		"REPLICATE_IGNORE_DB", "REPLICATE_IGNORE_TABLE", "REPLICATE_REWRITE_DB",
		"REPLICATE_WILD_DO_TABLE", "REPLICATE_WILD_IGNORE_TABLE", "REPLICATION",
		"RESET", "RESTART", "RESUME", "RETURNED_SQLSTATE", "RETURNING", "RETURNS",
		"REUSE", "ROLE", "ROLLBACK", "ROLLUP", "ROTATE", "ROW", "ROWS", "ROW_FORMAT",
		"RTREE", "SAVEPOINT", "SCHEDULE", "SECURITY", "SEQUENCE", "SERVER",
		"SESSION", "SHARE", "SHARED", "SIGNED", "SIMPLE", "SLAVE", "SLOW", "SNAPSHOT",
		"SOCKET", "SOME", "SONAME", "SOUNDS", "SOURCE", "SQL_AFTER_GTIDS", "SQL_AFTER_MTS_GAPS",
		"SQL_BEFORE_GTIDS", "SQL_BUFFER_RESULT", "SQL_CACHE", "SQL_NO_CACHE",
		"SQL_THREAD", "START", "STARTS", "STATS_AUTO_RECALC", "STATS_PERSISTENT",
		"STATS_SAMPLE_PAGES", "STATUS", "STOP", "STORAGE", "STORED", "STRING",
		"SUBCLASS_ORIGIN", "SUBJECT", "SUBPARTITION", "SUBPARTITIONS", "SUSPEND",
		"SWAPS", "SWITCHES", "TABLE_NAME", "TABLESPACE", "TABLE_TYPE", "TEMPORARY",
		"TEMPTABLE", "THAN", "TRADITIONAL", "TRANSACTION", "TRANSACTIONAL",
		"TRIGGERS", "TRUNCATE", "UNBOUNDED", "UNDEFINED", "UNDOFILE", "UNDO_BUFFER_SIZE",
		"UNINSTALL", "UNKNOWN", "UNTIL", "UPGRADE", "USER", "USE_FRM", "USER_RESOURCES",
		"VALIDATION", "VALUE", "VARIABLES", "VIEW", "VIRTUAL", "VISIBLE", "WAIT",
		"WARNINGS", "WINDOW", "WITHOUT", "WORK", "WRAPPER", "X509", "XA", "XML",
		"YES", "EUR", "USA", "JIS", "ISO", "INTERNAL", "QUARTER", "MONTH", "DAY",
		"HOUR", "MINUTE", "WEEK", "SECOND", "MICROSECOND", "ADMIN", "APPLICATION_PASSWORD_ADMIN",
		"AUDIT_ABORT_EXEMPT", "AUDIT_ADMIN", "AUTHENTICATION_POLICY_ADMIN",
		"BACKUP_ADMIN", "BINLOG_ADMIN", "BINLOG_ENCRYPTION_ADMIN", "CLONE_ADMIN",
		"CONNECTION_ADMIN", "ENCRYPTION_KEY_ADMIN", "EXECUTE", "FILE", "FIREWALL_ADMIN",
		"FIREWALL_EXEMPT", "FIREWALL_USER", "FLUSH_OPTIMIZER_COSTS", "FLUSH_STATUS",
		"FLUSH_TABLES", "FLUSH_USER_RESOURCES", "GROUP_REPLICATION_ADMIN", "INNODB_REDO_LOG_ARCHIVE",
		"INNODB_REDO_LOG_ENABLE", "INVOKE", "LAMBDA", "NDB_STORED_USER", "PASSWORDLESS_USER_ADMIN",
		"PERSIST_RO_VARIABLES_ADMIN", "PRIVILEGES", "PROCESS", "RELOAD", "REPLICATION_APPLIER",
		"REPLICATION_SLAVE_ADMIN", "RESOURCE_GROUP_ADMIN", "RESOURCE_GROUP_USER",
		"ROLE_ADMIN", "ROUTINE", "S3", "SERVICE_CONNECTION_ADMIN", "SESSION_VARIABLES_ADMIN",
		"SET_USER_ID", "SHOW_ROUTINE", "SHUTDOWN", "SUPER", "SYSTEM_VARIABLES_ADMIN",
		"TABLES", "TABLE_ENCRYPTION_ADMIN", "VERSION_TOKEN_ADMIN", "XA_RECOVER_ADMIN",
		"ARMSCII8", "ASCII", "BIG5", "CP1250", "CP1251", "CP1256", "CP1257",
		"CP850", "CP852", "CP866", "CP932", "DEC8", "EUCJPMS", "EUCKR", "GB18030",
		"GB2312", "GBK", "GEOSTD8", "GREEK", "HEBREW", "HP8", "KEYBCS2", "KOI8R",
		"KOI8U", "LATIN1", "LATIN2", "LATIN5", "LATIN7", "MACCE", "MACROMAN",
		"SJIS", "SWE7", "TIS620", "UCS2", "UJIS", "UTF16", "UTF16LE", "UTF32",
		"UTF8", "UTF8MB3", "UTF8MB4", "ARCHIVE", "BLACKHOLE", "CSV", "FEDERATED",
		"INNODB", "MEMORY", "MRG_MYISAM", "MYISAM", "NDB", "NDBCLUSTER", "PERFORMANCE_SCHEMA",
		"TOKUDB", "REPEATABLE", "COMMITTED", "UNCOMMITTED", "SERIALIZABLE",
		"GEOMETRYCOLLECTION", "GEOMCOLLECTION", "GEOMETRY", "LINESTRING", "MULTILINESTRING",
		"MULTIPOINT", "MULTIPOLYGON", "POINT", "POLYGON", "ABS", "ACOS", "ADDDATE",
		"ADDTIME", "AES_DECRYPT", "AES_ENCRYPT", "AREA", "ASBINARY", "ASIN",
		"ASTEXT", "ASWKB", "ASWKT", "ASYMMETRIC_DECRYPT", "ASYMMETRIC_DERIVE",
		"ASYMMETRIC_ENCRYPT", "ASYMMETRIC_SIGN", "ASYMMETRIC_VERIFY", "ATAN",
		"ATAN2", "BENCHMARK", "BIN", "BIT_COUNT", "BIT_LENGTH", "BUFFER", "CATALOG_NAME",
		"CEIL", "CEILING", "CENTROID", "CHARACTER_LENGTH", "CHARSET", "CHAR_LENGTH",
		"COERCIBILITY", "COLLATION", "COMPRESS", "CONCAT", "CONCAT_WS", "CONNECTION_ID",
		"CONV", "CONVERT_TZ", "COS", "COT", "CRC32", "CREATE_ASYMMETRIC_PRIV_KEY",
		"CREATE_ASYMMETRIC_PUB_KEY", "CREATE_DH_PARAMETERS", "CREATE_DIGEST",
		"CROSSES", "DATEDIFF", "DATE_FORMAT", "DAYNAME", "DAYOFMONTH", "DAYOFWEEK",
		"DAYOFYEAR", "DECODE", "DEGREES", "DES_DECRYPT", "DES_ENCRYPT", "DIMENSION",
		"DISJOINT", "ELT", "ENCODE", "ENCRYPT", "ENDPOINT", "ENGINE_ATTRIBUTE",
		"ENVELOPE", "EQUALS", "EXP", "EXPORT_SET", "EXTERIORRING", "EXTRACTVALUE",
		"FIELD", "FIND_IN_SET", "FLOOR", "FORMAT", "FOUND_ROWS", "FROM_BASE64",
		"FROM_DAYS", "FROM_UNIXTIME", "GEOMCOLLFROMTEXT", "GEOMCOLLFROMWKB",
		"GEOMETRYCOLLECTIONFROMTEXT", "GEOMETRYCOLLECTIONFROMWKB", "GEOMETRYFROMTEXT",
		"GEOMETRYFROMWKB", "GEOMETRYN", "GEOMETRYTYPE", "GEOMFROMTEXT", "GEOMFROMWKB",
		"GET_FORMAT", "GET_LOCK", "GLENGTH", "GREATEST", "GTID_SUBSET", "GTID_SUBTRACT",
		"HEX", "IFNULL", "INET6_ATON", "INET6_NTOA", "INET_ATON", "INET_NTOA",
		"INSTR", "INTERIORRINGN", "INTERSECTS", "ISCLOSED", "ISEMPTY", "ISNULL",
		"ISSIMPLE", "IS_FREE_LOCK", "IS_IPV4", "IS_IPV4_COMPAT", "IS_IPV4_MAPPED",
		"IS_IPV6", "IS_USED_LOCK", "LAST_INSERT_ID", "LCASE", "LEAST", "LENGTH",
		"LINEFROMTEXT", "LINEFROMWKB", "LINESTRINGFROMTEXT", "LINESTRINGFROMWKB",
		"LN", "LOAD_FILE", "LOCATE", "LOG", "LOG10", "LOG2", "LOWER", "LPAD",
		"LTRIM", "MAKEDATE", "MAKETIME", "MAKE_SET", "MASTER_POS_WAIT", "MBRCONTAINS",
		"MBRDISJOINT", "MBREQUAL", "MBRINTERSECTS", "MBROVERLAPS", "MBRTOUCHES",
		"MBRWITHIN", "MD5", "MLINEFROMTEXT", "MLINEFROMWKB", "MONTHNAME", "MPOINTFROMTEXT",
		"MPOINTFROMWKB", "MPOLYFROMTEXT", "MPOLYFROMWKB", "MULTILINESTRINGFROMTEXT",
		"MULTILINESTRINGFROMWKB", "MULTIPOINTFROMTEXT", "MULTIPOINTFROMWKB",
		"MULTIPOLYGONFROMTEXT", "MULTIPOLYGONFROMWKB", "NAME_CONST", "NULLIF",
		"NUMGEOMETRIES", "NUMINTERIORRINGS", "NUMPOINTS", "OCT", "OCTET_LENGTH",
		"ORD", "OVERLAPS", "PERIOD_ADD", "PERIOD_DIFF", "PI", "POINTFROMTEXT",
		"POINTFROMWKB", "POINTN", "POLYFROMTEXT", "POLYFROMWKB", "POLYGONFROMTEXT",
		"POLYGONFROMWKB", "POW", "POWER", "QUOTE", "RADIANS", "RAND", "RANDOM",
		"RANDOM_BYTES", "RELEASE_LOCK", "REVERSE", "ROUND", "ROW_COUNT", "RPAD",
		"RTRIM", "SEC_TO_TIME", "SECONDARY_ENGINE_ATTRIBUTE", "SESSION_USER",
		"SHA", "SHA1", "SHA2", "SCHEMA_NAME", "SIGN", "SIN", "SLEEP", "SOUNDEX",
		"SQL_THREAD_WAIT_AFTER_GTIDS", "SQRT", "SRID", "STARTPOINT", "STRCMP",
		"STR_TO_DATE", "ST_AREA", "ST_ASBINARY", "ST_ASTEXT", "ST_ASWKB", "ST_ASWKT",
		"ST_BUFFER", "ST_CENTROID", "ST_CONTAINS", "ST_CROSSES", "ST_DIFFERENCE",
		"ST_DIMENSION", "ST_DISJOINT", "ST_DISTANCE", "ST_ENDPOINT", "ST_ENVELOPE",
		"ST_EQUALS", "ST_EXTERIORRING", "ST_GEOMCOLLFROMTEXT", "ST_GEOMCOLLFROMTXT",
		"ST_GEOMCOLLFROMWKB", "ST_GEOMETRYCOLLECTIONFROMTEXT", "ST_GEOMETRYCOLLECTIONFROMWKB",
		"ST_GEOMETRYFROMTEXT", "ST_GEOMETRYFROMWKB", "ST_GEOMETRYN", "ST_GEOMETRYTYPE",
		"ST_GEOMFROMTEXT", "ST_GEOMFROMWKB", "ST_INTERIORRINGN", "ST_INTERSECTION",
		"ST_INTERSECTS", "ST_ISCLOSED", "ST_ISEMPTY", "ST_ISSIMPLE", "ST_LINEFROMTEXT",
		"ST_LINEFROMWKB", "ST_LINESTRINGFROMTEXT", "ST_LINESTRINGFROMWKB", "ST_NUMGEOMETRIES",
		"ST_NUMINTERIORRING", "ST_NUMINTERIORRINGS", "ST_NUMPOINTS", "ST_OVERLAPS",
		"ST_POINTFROMTEXT", "ST_POINTFROMWKB", "ST_POINTN", "ST_POLYFROMTEXT",
		"ST_POLYFROMWKB", "ST_POLYGONFROMTEXT", "ST_POLYGONFROMWKB", "ST_SRID",
		"ST_STARTPOINT", "ST_SYMDIFFERENCE", "ST_TOUCHES", "ST_UNION", "ST_WITHIN",
		"ST_X", "ST_Y", "SUBDATE", "SUBSTRING_INDEX", "SUBTIME", "SYSTEM_USER",
		"TAN", "TIMEDIFF", "TIMESTAMPADD", "TIMESTAMPDIFF", "TIME_FORMAT", "TIME_TO_SEC",
		"TOUCHES", "TO_BASE64", "TO_DAYS", "TO_SECONDS", "TP_CONNECTION_ADMIN",
		"UCASE", "UNCOMPRESS", "UNCOMPRESSED_LENGTH", "UNHEX", "UNIX_TIMESTAMP",
		"UPDATEXML", "UPPER", "UUID", "UUID_SHORT", "VALIDATE_PASSWORD_STRENGTH",
		"VERSION", "WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS", "WEEKDAY", "WEEKOFYEAR",
		"WEIGHT_STRING", "WITHIN", "YEARWEEK", "Y_FUNCTION", "X_FUNCTION", "VAR_ASSIGN",
		"PLUS_ASSIGN", "MINUS_ASSIGN", "MULT_ASSIGN", "DIV_ASSIGN", "MOD_ASSIGN",
		"AND_ASSIGN", "XOR_ASSIGN", "OR_ASSIGN", "STAR", "DIVIDE", "MODULE",
		"PLUS", "MINUS", "DIV", "MOD", "EQUAL_SYMBOL", "GREATER_SYMBOL", "LESS_SYMBOL",
		"EXCLAMATION_SYMBOL", "BIT_NOT_OP", "BIT_OR_OP", "BIT_AND_OP", "BIT_XOR_OP",
		"DOT", "LR_BRACKET", "RR_BRACKET", "COMMA", "SEMI", "AT_SIGN", "ZERO_DECIMAL",
		"ONE_DECIMAL", "TWO_DECIMAL", "SINGLE_QUOTE_SYMB", "DOUBLE_QUOTE_SYMB",
		"REVERSE_QUOTE_SYMB", "COLON_SYMB", "CHARSET_REVERSE_QOUTE_STRING",
		"FILESIZE_LITERAL", "START_NATIONAL_STRING_LITERAL", "STRING_LITERAL",
		"DECIMAL_LITERAL", "HEXADECIMAL_LITERAL", "REAL_LITERAL", "NULL_SPEC_LITERAL",
		"BIT_STRING", "STRING_CHARSET_NAME", "DOT_ID", "ID", "REVERSE_QUOTE_ID",
		"HOST_IP_ADDRESS", "LOCAL_ID", "GLOBAL_ID", "ERROR_RECONGNIGION",
	}
	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, 1161, 7450, 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, 1, 220, 1, 220, 5, 220, 5264, 8,
		220, 10, 220, 12, 220, 5267, 9, 220, 1, 220, 1, 220, 3, 220, 5271, 8, 220,
		1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 5, 220, 5278, 8, 220, 10, 220,
		12, 220, 5281, 9, 220, 1, 220, 1, 220, 1, 220, 3, 220, 5286, 8, 220, 1,
		220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 5, 220, 5295, 8, 220,
		10, 220, 12, 220, 5298, 9, 220, 1, 220, 1, 220, 1, 220, 3, 220, 5303, 8,
		220, 1, 220, 1, 220, 1, 220, 3, 220, 5308, 8, 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, 1, 220, 3, 220, 5323, 8, 220, 5, 220, 5325, 8, 220,
		10, 220, 12, 220, 5328, 9, 220, 3, 220, 5330, 8, 220, 1, 221, 1, 221, 1,
		221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 5, 221, 5340, 8, 221, 10,
		221, 12, 221, 5343, 9, 221, 1, 222, 1, 222, 1, 222, 1, 222, 3, 222, 5349,
		8, 222, 1, 222, 1, 222, 1, 222, 3, 222, 5354, 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, 5384,
		8, 224, 1, 225, 1, 225, 3, 225, 5388, 8, 225, 1, 225, 1, 225, 1, 225, 3,
		225, 5393, 8, 225, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 3, 226, 5400,
		8, 226, 1, 226, 3, 226, 5403, 8, 226, 1, 226, 1, 226, 1, 226, 1, 226, 3,
		226, 5409, 8, 226, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227,
		1, 227, 3, 227, 5419, 8, 227, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1,
		228, 1, 228, 1, 228, 3, 228, 5429, 8, 228, 1, 229, 1, 229, 1, 229, 1, 229,
		1, 229, 1, 229, 1, 229, 1, 229, 3, 229, 5439, 8, 229, 1, 229, 1, 229, 1,
		229, 1, 229, 3, 229, 5445, 8, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229,
		1, 229, 1, 229, 3, 229, 5454, 8, 229, 1, 229, 1, 229, 1, 229, 1, 229, 3,
		229, 5460, 8, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 3, 229, 5467,
		8, 229, 3, 229, 5469, 8, 229, 1, 230, 1, 230, 1, 230, 1, 231, 1, 231, 1,
		231, 1, 231, 1, 231, 3, 231, 5479, 8, 231, 1, 232, 1, 232, 3, 232, 5483,
		8, 232, 1, 232, 1, 232, 3, 232, 5487, 8, 232, 1, 232, 1, 232, 1, 232, 1,
		232, 1, 232, 1, 232, 1, 232, 1, 232, 3, 232, 5497, 8, 232, 1, 232, 1, 232,
		1, 232, 3, 232, 5502, 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, 5574, 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, 5592, 8, 233, 1, 234, 1, 234, 1, 234, 1, 234, 1,
		235, 1, 235, 3, 235, 5600, 8, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235,
		1, 235, 1, 235, 1, 235, 5, 235, 5610, 8, 235, 10, 235, 12, 235, 5613, 9,
		235, 1, 235, 1, 235, 1, 235, 1, 235, 3, 235, 5619, 8, 235, 3, 235, 5621,
		8, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 5, 235, 5629, 8,
		235, 10, 235, 12, 235, 5632, 9, 235, 3, 235, 5634, 8, 235, 1, 236, 1, 236,
		1, 236, 1, 236, 5, 236, 5640, 8, 236, 10, 236, 12, 236, 5643, 9, 236, 1,
		237, 1, 237, 1, 237, 1, 237, 3, 237, 5649, 8, 237, 1, 238, 1, 238, 3, 238,
		5653, 8, 238, 1, 238, 1, 238, 1, 238, 1, 239, 1, 239, 3, 239, 5660, 8,
		239, 1, 239, 1, 239, 1, 239, 3, 239, 5665, 8, 239, 1, 239, 3, 239, 5668,
		8, 239, 1, 239, 3, 239, 5671, 8, 239, 1, 240, 1, 240, 1, 240, 1, 240, 1,
		240, 1, 240, 1, 240, 3, 240, 5680, 8, 240, 1, 241, 1, 241, 3, 241, 5684,
		8, 241, 1, 241, 1, 241, 3, 241, 5688, 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, 5711, 8, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 3, 244, 5718,
		8, 244, 5, 244, 5720, 8, 244, 10, 244, 12, 244, 5723, 9, 244, 1, 244, 1,
		244, 1, 244, 1, 244, 3, 244, 5729, 8, 244, 1, 244, 1, 244, 1, 244, 1, 244,
		1, 244, 3, 244, 5736, 8, 244, 1, 244, 3, 244, 5739, 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, 5753, 8, 244, 10, 244, 12, 244, 5756, 9, 244, 3, 244,
		5758, 8, 244, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1,
		245, 3, 245, 5768, 8, 245, 1, 245, 1, 245, 3, 245, 5772, 8, 245, 1, 245,
		1, 245, 1, 245, 1, 245, 3, 245, 5778, 8, 245, 1, 245, 3, 245, 5781, 8,
		245, 1, 245, 1, 245, 1, 245, 3, 245, 5786, 8, 245, 1, 245, 1, 245, 3, 245,
		5790, 8, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 3, 245, 5797, 8,
		245, 1, 245, 3, 245, 5800, 8, 245, 1, 245, 1, 245, 1, 245, 1, 245, 3, 245,
		5806, 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, 5830, 8, 245, 1, 245,
		3, 245, 5833, 8, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1,
		245, 1, 245, 1, 245, 1, 245, 3, 245, 5845, 8, 245, 1, 245, 3, 245, 5848,
		8, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245,
		3, 245, 5858, 8, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 3,
		245, 5866, 8, 245, 1, 245, 1, 245, 3, 245, 5870, 8, 245, 1, 245, 1, 245,
		1, 245, 1, 245, 1, 245, 3, 245, 5877, 8, 245, 1, 245, 3, 245, 5880, 8,
		245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 5, 245, 5887, 8, 245, 10,
		245, 12, 245, 5890, 9, 245, 1, 245, 1, 245, 1, 245, 3, 245, 5895, 8, 245,
		1, 245, 1, 245, 1, 245, 1, 245, 3, 245, 5901, 8, 245, 1, 245, 1, 245, 1,
		245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 3, 245, 5911, 8, 245, 3, 245,
		5913, 8, 245, 1, 246, 1, 246, 1, 246, 1, 246, 3, 246, 5919, 8, 246, 1,
		246, 3, 246, 5922, 8, 246, 1, 246, 3, 246, 5925, 8, 246, 1, 247, 1, 247,
		1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 3, 247,
		5937, 8, 247, 1, 247, 3, 247, 5940, 8, 247, 1, 248, 1, 248, 1, 248, 1,
		248, 3, 248, 5946, 8, 248, 1, 249, 3, 249, 5949, 8, 249, 1, 249, 1, 249,
		1, 249, 1, 249, 1, 249, 1, 249, 3, 249, 5957, 8, 249, 1, 249, 1, 249, 1,
		249, 1, 249, 1, 249, 1, 249, 3, 249, 5965, 8, 249, 1, 250, 1, 250, 1, 250,
		1, 250, 3, 250, 5971, 8, 250, 1, 250, 1, 250, 3, 250, 5975, 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, 5989, 8, 251, 1, 252, 1, 252, 1, 252, 1, 253,
		1, 253, 1, 253, 1, 253, 1, 253, 5, 253, 5999, 8, 253, 10, 253, 12, 253,
		6002, 9, 253, 1, 253, 1, 253, 1, 253, 1, 253, 3, 253, 6008, 8, 253, 1,
		253, 3, 253, 6011, 8, 253, 1, 253, 1, 253, 1, 253, 1, 254, 1, 254, 3, 254,
		6018, 8, 254, 1, 254, 1, 254, 1, 254, 5, 254, 6023, 8, 254, 10, 254, 12,
		254, 6026, 9, 254, 1, 255, 1, 255, 3, 255, 6030, 8, 255, 1, 255, 1, 255,
		1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 5, 256, 6041, 8,
		256, 10, 256, 12, 256, 6044, 9, 256, 1, 257, 1, 257, 1, 257, 1, 257, 1,
		258, 1, 258, 1, 259, 1, 259, 3, 259, 6054, 8, 259, 1, 259, 1, 259, 1, 259,
		1, 259, 3, 259, 6060, 8, 259, 1, 260, 1, 260, 1, 260, 3, 260, 6065, 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, 6078, 8, 260, 3, 260, 6080, 8, 260, 1, 260,
		1, 260, 1, 260, 3, 260, 6085, 8, 260, 1, 260, 1, 260, 3, 260, 6089, 8,
		260, 1, 260, 3, 260, 6092, 8, 260, 3, 260, 6094, 8, 260, 1, 261, 1, 261,
		1, 261, 1, 261, 1, 261, 3, 261, 6101, 8, 261, 1, 262, 1, 262, 1, 262, 1,
		262, 1, 262, 3, 262, 6108, 8, 262, 1, 262, 3, 262, 6111, 8, 262, 1, 262,
		3, 262, 6114, 8, 262, 1, 262, 1, 262, 1, 262, 1, 262, 3, 262, 6120, 8,
		262, 1, 262, 1, 262, 3, 262, 6124, 8, 262, 1, 263, 1, 263, 1, 263, 1, 263,
		3, 263, 6130, 8, 263, 1, 264, 1, 264, 1, 264, 1, 264, 3, 264, 6136, 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, 6149, 8, 267, 1, 267, 1, 267, 1, 267, 3, 267,
		6154, 8, 267, 1, 267, 1, 267, 1, 267, 1, 267, 5, 267, 6160, 8, 267, 10,
		267, 12, 267, 6163, 9, 267, 3, 267, 6165, 8, 267, 1, 268, 1, 268, 1, 268,
		3, 268, 6170, 8, 268, 1, 268, 1, 268, 1, 268, 3, 268, 6175, 8, 268, 1,
		268, 1, 268, 1, 268, 1, 268, 5, 268, 6181, 8, 268, 10, 268, 12, 268, 6184,
		9, 268, 3, 268, 6186, 8, 268, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1,
		269, 3, 269, 6194, 8, 269, 1, 270, 1, 270, 3, 270, 6198, 8, 270, 1, 270,
		1, 270, 1, 270, 5, 270, 6203, 8, 270, 10, 270, 12, 270, 6206, 9, 270, 1,
		271, 1, 271, 1, 271, 3, 271, 6211, 8, 271, 1, 271, 3, 271, 6214, 8, 271,
		1, 272, 1, 272, 3, 272, 6218, 8, 272, 1, 272, 1, 272, 1, 272, 1, 272, 1,
		272, 1, 272, 1, 272, 1, 272, 1, 272, 5, 272, 6229, 8, 272, 10, 272, 12,
		272, 6232, 9, 272, 1, 272, 1, 272, 1, 272, 3, 272, 6237, 8, 272, 1, 272,
		1, 272, 1, 272, 1, 272, 1, 272, 1, 272, 1, 272, 1, 272, 5, 272, 6247, 8,
		272, 10, 272, 12, 272, 6250, 9, 272, 3, 272, 6252, 8, 272, 1, 273, 1, 273,
		1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 3, 274, 6261, 8, 274, 1, 274, 1,
		274, 1, 274, 3, 274, 6266, 8, 274, 1, 275, 1, 275, 1, 275, 1, 275, 3, 275,
		6272, 8, 275, 1, 276, 1, 276, 1, 277, 1, 277, 3, 277, 6278, 8, 277, 1,
		278, 1, 278, 1, 278, 3, 278, 6283, 8, 278, 3, 278, 6285, 8, 278, 1, 278,
		3, 278, 6288, 8, 278, 1, 278, 1, 278, 3, 278, 6292, 8, 278, 3, 278, 6294,
		8, 278, 1, 279, 1, 279, 3, 279, 6298, 8, 279, 1, 279, 1, 279, 1, 279, 1,
		279, 3, 279, 6304, 8, 279, 1, 279, 3, 279, 6307, 8, 279, 1, 279, 3, 279,
		6310, 8, 279, 1, 280, 1, 280, 1, 280, 1, 280, 3, 280, 6316, 8, 280, 1,
		281, 1, 281, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 3, 282, 6325, 8, 282,
		1, 283, 1, 283, 1, 284, 1, 284, 1, 284, 1, 284, 3, 284, 6333, 8, 284, 1,
		285, 1, 285, 3, 285, 6337, 8, 285, 1, 286, 1, 286, 1, 286, 3, 286, 6342,
		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,
		6360, 8, 288, 11, 288, 12, 288, 6361, 1, 289, 1, 289, 1, 289, 1, 289, 1,
		289, 3, 289, 6369, 8, 289, 3, 289, 6371, 8, 289, 1, 290, 1, 290, 1, 290,
		4, 290, 6376, 8, 290, 11, 290, 12, 290, 6377, 3, 290, 6380, 8, 290, 1,
		291, 1, 291, 3, 291, 6384, 8, 291, 1, 292, 1, 292, 1, 292, 3, 292, 6389,
		8, 292, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293,
		1, 293, 3, 293, 6400, 8, 293, 1, 294, 1, 294, 1, 294, 3, 294, 6405, 8,
		294, 1, 295, 1, 295, 1, 296, 1, 296, 3, 296, 6411, 8, 296, 1, 297, 3, 297,
		6414, 8, 297, 1, 297, 1, 297, 3, 297, 6418, 8, 297, 1, 297, 4, 297, 6421,
		8, 297, 11, 297, 12, 297, 6422, 1, 297, 3, 297, 6426, 8, 297, 1, 297, 1,
		297, 3, 297, 6430, 8, 297, 1, 297, 1, 297, 3, 297, 6434, 8, 297, 3, 297,
		6436, 8, 297, 1, 298, 1, 298, 1, 299, 3, 299, 6441, 8, 299, 1, 299, 1,
		299, 1, 300, 3, 300, 6446, 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, 6459, 8, 301, 1,
		301, 3, 301, 6462, 8, 301, 1, 302, 1, 302, 3, 302, 6466, 8, 302, 1, 302,
		3, 302, 6469, 8, 302, 1, 302, 3, 302, 6472, 8, 302, 1, 302, 1, 302, 1,
		302, 3, 302, 6477, 8, 302, 1, 302, 1, 302, 1, 302, 3, 302, 6482, 8, 302,
		1, 302, 1, 302, 1, 302, 1, 302, 3, 302, 6488, 8, 302, 1, 302, 3, 302, 6491,
		8, 302, 1, 302, 1, 302, 1, 302, 3, 302, 6496, 8, 302, 1, 302, 3, 302, 6499,
		8, 302, 1, 302, 1, 302, 1, 302, 3, 302, 6504, 8, 302, 1, 302, 3, 302, 6507,
		8, 302, 1, 302, 1, 302, 3, 302, 6511, 8, 302, 1, 302, 5, 302, 6514, 8,
		302, 10, 302, 12, 302, 6517, 9, 302, 1, 302, 1, 302, 3, 302, 6521, 8, 302,
		1, 302, 5, 302, 6524, 8, 302, 10, 302, 12, 302, 6527, 9, 302, 1, 302, 1,
		302, 3, 302, 6531, 8, 302, 1, 302, 3, 302, 6534, 8, 302, 1, 302, 5, 302,
		6537, 8, 302, 10, 302, 12, 302, 6540, 9, 302, 1, 302, 1, 302, 3, 302, 6544,
		8, 302, 1, 302, 5, 302, 6547, 8, 302, 10, 302, 12, 302, 6550, 9, 302, 1,
		302, 1, 302, 1, 302, 3, 302, 6555, 8, 302, 1, 302, 1, 302, 1, 302, 3, 302,
		6560, 8, 302, 1, 302, 1, 302, 1, 302, 3, 302, 6565, 8, 302, 1, 302, 1,
		302, 1, 302, 3, 302, 6570, 8, 302, 1, 302, 1, 302, 3, 302, 6574, 8, 302,
		1, 302, 3, 302, 6577, 8, 302, 1, 302, 1, 302, 1, 302, 3, 302, 6582, 8,
		302, 1, 302, 1, 302, 3, 302, 6586, 8, 302, 1, 302, 1, 302, 3, 302, 6590,
		8, 302, 1, 303, 1, 303, 1, 303, 1, 303, 5, 303, 6596, 8, 303, 10, 303,
		12, 303, 6599, 9, 303, 1, 303, 1, 303, 1, 304, 1, 304, 3, 304, 6605, 8,
		304, 1, 304, 1, 304, 3, 304, 6609, 8, 304, 1, 304, 1, 304, 1, 304, 3, 304,
		6614, 8, 304, 1, 304, 1, 304, 1, 304, 3, 304, 6619, 8, 304, 1, 304, 1,
		304, 3, 304, 6623, 8, 304, 3, 304, 6625, 8, 304, 1, 304, 3, 304, 6628,
		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, 6644, 8, 307, 1,
		307, 1, 307, 1, 308, 1, 308, 1, 308, 5, 308, 6651, 8, 308, 10, 308, 12,
		308, 6654, 9, 308, 1, 309, 1, 309, 1, 309, 5, 309, 6659, 8, 309, 10, 309,
		12, 309, 6662, 9, 309, 1, 310, 1, 310, 1, 310, 5, 310, 6667, 8, 310, 10,
		310, 12, 310, 6670, 9, 310, 1, 311, 1, 311, 1, 311, 1, 311, 5, 311, 6676,
		8, 311, 10, 311, 12, 311, 6679, 9, 311, 1, 311, 1, 311, 1, 312, 1, 312,
		1, 312, 5, 312, 6686, 8, 312, 10, 312, 12, 312, 6689, 9, 312, 1, 313, 1,
		313, 1, 313, 5, 313, 6694, 8, 313, 10, 313, 12, 313, 6697, 9, 313, 1, 314,
		1, 314, 1, 314, 5, 314, 6702, 8, 314, 10, 314, 12, 314, 6705, 9, 314, 1,
		315, 1, 315, 1, 315, 5, 315, 6710, 8, 315, 10, 315, 12, 315, 6713, 9, 315,
		1, 316, 1, 316, 1, 316, 5, 316, 6718, 8, 316, 10, 316, 12, 316, 6721, 9,
		316, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1,
		317, 3, 317, 6732, 8, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 3, 317,
		6739, 8, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1,
		317, 3, 317, 6749, 8, 317, 1, 318, 1, 318, 1, 318, 3, 318, 6754, 8, 318,
		1, 318, 3, 318, 6757, 8, 318, 1, 318, 1, 318, 1, 318, 3, 318, 6762, 8,
		318, 1, 318, 3, 318, 6765, 8, 318, 1, 319, 1, 319, 3, 319, 6769, 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, 6784, 8, 323, 1, 324, 1, 324, 1,
		324, 1, 324, 1, 324, 1, 324, 3, 324, 6792, 8, 324, 1, 324, 1, 324, 1, 324,
		1, 324, 1, 324, 3, 324, 6799, 8, 324, 1, 324, 1, 324, 1, 324, 3, 324, 6804,
		8, 324, 1, 325, 1, 325, 1, 325, 3, 325, 6809, 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, 6841, 8, 325, 11, 325, 12, 325, 6842, 1, 325, 1, 325, 3, 325,
		6847, 8, 325, 1, 325, 1, 325, 1, 325, 1, 325, 4, 325, 6853, 8, 325, 11,
		325, 12, 325, 6854, 1, 325, 1, 325, 3, 325, 6859, 8, 325, 1, 325, 1, 325,
		1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 3, 325, 6868, 8, 325, 1, 325, 1,
		325, 1, 325, 1, 325, 1, 325, 1, 325, 3, 325, 6876, 8, 325, 1, 325, 1, 325,
		1, 325, 3, 325, 6881, 8, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1,
		325, 3, 325, 6889, 8, 325, 1, 325, 1, 325, 1, 325, 3, 325, 6894, 8, 325,
		1, 325, 1, 325, 1, 325, 3, 325, 6899, 8, 325, 3, 325, 6901, 8, 325, 1,
		325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 3, 325, 6910, 8, 325,
		1, 325, 1, 325, 1, 325, 3, 325, 6915, 8, 325, 1, 325, 1, 325, 1, 325, 1,
		325, 1, 325, 1, 325, 3, 325, 6923, 8, 325, 1, 325, 1, 325, 1, 325, 3, 325,
		6928, 8, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 3, 325, 6936,
		8, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 3, 325, 6944, 8,
		325, 1, 325, 3, 325, 6947, 8, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325,
		1, 325, 1, 325, 1, 325, 3, 325, 6957, 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, 6975, 8, 325, 1, 325, 3, 325, 6978,
		8, 325, 1, 325, 3, 325, 6981, 8, 325, 1, 325, 1, 325, 3, 325, 6985, 8,
		325, 1, 326, 1, 326, 1, 326, 1, 326, 1, 326, 1, 327, 1, 327, 1, 327, 1,
		327, 5, 327, 6996, 8, 327, 10, 327, 12, 327, 6999, 9, 327, 1, 327, 1, 327,
		1, 327, 1, 327, 1, 327, 3, 327, 7006, 8, 327, 1, 328, 1, 328, 3, 328, 7010,
		8, 328, 1, 329, 1, 329, 1, 329, 3, 329, 7015, 8, 329, 1, 329, 1, 329, 1,
		329, 3, 329, 7020, 8, 329, 1, 329, 1, 329, 1, 329, 1, 329, 3, 329, 7026,
		8, 329, 1, 329, 1, 329, 1, 329, 3, 329, 7031, 8, 329, 1, 329, 1, 329, 3,
		329, 7035, 8, 329, 1, 329, 1, 329, 1, 329, 3, 329, 7040, 8, 329, 1, 329,
		1, 329, 1, 329, 3, 329, 7045, 8, 329, 1, 329, 1, 329, 1, 329, 3, 329, 7050,
		8, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 5, 329, 7058, 8,
		329, 10, 329, 12, 329, 7061, 9, 329, 3, 329, 7063, 8, 329, 1, 329, 1, 329,
		3, 329, 7067, 8, 329, 1, 329, 1, 329, 3, 329, 7071, 8, 329, 1, 330, 1,
		330, 1, 330, 1, 330, 1, 330, 3, 330, 7078, 8, 330, 1, 330, 1, 330, 3, 330,
		7082, 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, 7111, 8, 330, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331,
		1, 331, 3, 331, 7119, 8, 331, 1, 332, 3, 332, 7122, 8, 332, 1, 332, 3,
		332, 7125, 8, 332, 1, 332, 3, 332, 7128, 8, 332, 1, 332, 3, 332, 7131,
		8, 332, 1, 333, 1, 333, 1, 334, 1, 334, 1, 334, 1, 335, 1, 335, 1, 336,
		1, 336, 3, 336, 7142, 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, 7156, 8, 338,
		1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 5, 339, 7163, 8, 339, 10, 339,
		12, 339, 7166, 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, 7192, 8, 340, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 342, 1,
		342, 1, 342, 1, 342, 3, 342, 7203, 8, 342, 1, 342, 1, 342, 1, 342, 1, 342,
		1, 342, 3, 342, 7210, 8, 342, 5, 342, 7212, 8, 342, 10, 342, 12, 342, 7215,
		9, 342, 1, 343, 1, 343, 1, 343, 1, 343, 3, 343, 7221, 8, 343, 1, 344, 1,
		344, 1, 344, 1, 344, 1, 344, 1, 344, 3, 344, 7229, 8, 344, 1, 344, 1, 344,
		1, 344, 3, 344, 7234, 8, 344, 1, 344, 1, 344, 1, 344, 1, 344, 5, 344, 7240,
		8, 344, 10, 344, 12, 344, 7243, 9, 344, 1, 345, 1, 345, 1, 345, 1, 345,
		1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7254, 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, 7267, 8, 345, 1, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7273,
		8, 345, 1, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7279, 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, 7295, 8, 345, 1, 345, 1, 345, 1, 345,
		1, 345, 3, 345, 7301, 8, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1,
		345, 1, 345, 5, 345, 7310, 8, 345, 10, 345, 12, 345, 7313, 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, 7332, 8,
		346, 10, 346, 12, 346, 7335, 9, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1,
		346, 1, 346, 1, 346, 4, 346, 7344, 8, 346, 11, 346, 12, 346, 7345, 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, 7363, 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, 7384, 8, 346, 10, 346, 12, 346, 7387, 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, 7405, 8, 348, 1, 349, 1, 349, 1,
		349, 1, 349, 1, 349, 1, 349, 1, 349, 3, 349, 7414, 8, 349, 1, 350, 1, 350,
		1, 350, 1, 350, 1, 350, 1, 350, 1, 350, 3, 350, 7423, 8, 350, 1, 351, 1,
		351, 1, 352, 1, 352, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 3, 353, 7434,
		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, 531, 531, 537, 537, 3, 0, 69, 69, 159, 159, 181, 181, 3, 0, 42, 42,
		384, 384, 454, 454, 4, 0, 42, 42, 419, 419, 529, 529, 611, 611, 2, 0, 514,
		514, 1148, 1148, 2, 0, 78, 78, 141, 141, 2, 0, 15, 15, 334, 334, 3, 0,
		44, 44, 85, 85, 184, 184, 2, 0, 434, 434, 558, 558, 3, 0, 506, 506, 650,
		650, 658, 658, 2, 0, 392, 392, 460, 460, 2, 0, 352, 352, 474, 474, 2, 0,
		42, 42, 1138, 1139, 2, 0, 350, 350, 443, 443, 2, 0, 459, 459, 673, 673,
		3, 0, 80, 80, 84, 84, 125, 125, 3, 0, 42, 42, 402, 402, 431, 431, 3, 0,
		42, 42, 398, 398, 792, 792, 2, 0, 637, 637, 672, 672, 2, 0, 81, 81, 91,
		91, 3, 0, 436, 436, 548, 548, 613, 613, 2, 0, 69, 69, 159, 159, 1, 0, 356,
		357, 1, 0, 1138, 1139, 2, 0, 1148, 1148, 1156, 1156, 2, 0, 81, 81, 388,
		388, 2, 0, 545, 545, 1148, 1148, 2, 0, 546, 546, 1148, 1148, 3, 0, 430,
		430, 469, 469, 521, 521, 7, 0, 42, 42, 370, 370, 372, 372, 402, 402, 431,
		431, 573, 573, 1156, 1156, 2, 0, 514, 514, 530, 530, 1, 0, 1139, 1140,
		2, 0, 5, 5, 51, 51, 4, 0, 42, 42, 384, 384, 454, 454, 458, 458, 2, 0, 26,
		26, 30, 30, 2, 0, 12, 12, 175, 175, 2, 0, 192, 192, 677, 677, 2, 0, 21,
		21, 144, 144, 3, 0, 43, 43, 75, 75, 106, 106, 2, 0, 106, 106, 374, 374,
		2, 0, 365, 365, 427, 427, 2, 0, 101, 101, 601, 601, 2, 0, 43, 43, 106,
		106, 2, 0, 6, 6, 49, 49, 2, 0, 188, 188, 669, 669, 4, 0, 430, 430, 469,
		469, 520, 520, 562, 562, 2, 0, 430, 430, 520, 520, 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, 626, 627, 2, 0, 172, 172, 742, 742, 2, 0,
		439, 439, 609, 609, 2, 0, 226, 226, 477, 477, 5, 0, 107, 107, 482, 483,
		485, 485, 489, 497, 575, 575, 4, 0, 479, 480, 484, 484, 486, 487, 576,
		576, 3, 0, 108, 108, 478, 478, 488, 488, 2, 0, 462, 462, 628, 628, 2, 0,
		622, 622, 624, 624, 2, 0, 344, 344, 629, 629, 2, 0, 90, 90, 591, 591, 2,
		0, 51, 51, 390, 390, 3, 0, 31, 31, 61, 61, 179, 179, 3, 0, 131, 131, 172,
		172, 437, 437, 3, 0, 12, 12, 19, 19, 187, 187, 2, 0, 42, 42, 121, 121,
		2, 0, 103, 103, 182, 182, 2, 0, 360, 360, 614, 614, 2, 0, 40, 40, 671,
		671, 2, 0, 115, 115, 474, 474, 2, 0, 422, 422, 568, 568, 4, 0, 206, 206,
		208, 208, 214, 214, 638, 638, 2, 0, 1108, 1108, 1124, 1124, 2, 0, 345,
		345, 577, 577, 2, 0, 68, 68, 80, 80, 6, 0, 131, 131, 172, 172, 177, 177,
		415, 415, 437, 437, 671, 671, 2, 0, 513, 513, 634, 634, 2, 0, 412, 412,
		675, 675, 2, 0, 131, 131, 437, 437, 3, 0, 81, 81, 92, 92, 452, 452, 3,
		0, 439, 439, 474, 474, 609, 609, 2, 0, 634, 634, 670, 670, 2, 0, 376, 376,
		567, 567, 6, 0, 226, 226, 409, 409, 411, 411, 438, 438, 574, 574, 615,
		615, 2, 0, 45, 46, 62, 62, 3, 0, 422, 422, 550, 550, 885, 885, 2, 0, 466,
		466, 652, 652, 10, 0, 359, 359, 367, 367, 378, 380, 387, 387, 507, 507,
		515, 515, 639, 639, 646, 646, 836, 836, 1005, 1005, 2, 0, 35, 35, 168,
		168, 2, 0, 117, 117, 996, 996, 11, 0, 359, 359, 367, 367, 378, 380, 387,
		387, 507, 507, 515, 515, 592, 592, 639, 639, 646, 646, 836, 836, 1005,
		1005, 2, 0, 1137, 1137, 1158, 1159, 1, 0, 1159, 1160, 2, 0, 375, 375, 787,
		798, 3, 0, 1138, 1140, 1149, 1149, 1151, 1151, 2, 0, 63, 63, 178, 178,
		2, 0, 116, 116, 1152, 1152, 5, 0, 25, 25, 222, 224, 231, 231, 233, 236,
		518, 518, 2, 0, 25, 25, 222, 222, 2, 0, 25, 25, 222, 223, 1, 0, 196, 207,
		3, 0, 183, 183, 195, 195, 612, 612, 2, 0, 211, 216, 431, 431, 6, 0, 217,
		217, 228, 228, 230, 230, 232, 232, 239, 239, 348, 349, 4, 0, 218, 221,
		226, 227, 229, 229, 346, 346, 2, 0, 153, 153, 237, 237, 2, 0, 466, 466,
		803, 811, 3, 0, 211, 211, 226, 226, 518, 518, 6, 0, 200, 200, 206, 206,
		209, 209, 217, 218, 220, 221, 466, 466, 1, 0, 214, 215, 2, 0, 183, 183,
		612, 612, 2, 0, 200, 200, 206, 206, 2, 0, 315, 316, 322, 322, 3, 0, 150,
		150, 313, 316, 331, 331, 1, 0, 325, 326, 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,
		994, 994, 3, 0, 286, 286, 298, 299, 309, 309, 3, 0, 287, 289, 305, 308,
		310, 312, 2, 0, 295, 295, 297, 297, 2, 0, 293, 293, 296, 296, 2, 0, 291,
		292, 302, 304, 2, 0, 133, 133, 601, 601, 2, 0, 433, 433, 559, 559, 2, 0,
		535, 535, 551, 551, 2, 0, 114, 114, 1127, 1127, 3, 0, 63, 63, 178, 178,
		662, 662, 2, 0, 137, 137, 149, 149, 3, 0, 6, 6, 337, 337, 618, 618, 3,
		0, 114, 114, 1120, 1121, 1127, 1128, 2, 0, 1117, 1119, 1122, 1123, 1, 0,
		1120, 1121, 2, 0, 226, 226, 746, 786, 1, 0, 799, 802, 5, 0, 708, 709, 725,
		727, 733, 733, 739, 740, 742, 742, 1, 0, 689, 696, 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, 283, 290, 294, 294,
		298, 299, 305, 312, 332, 385, 387, 403, 405, 405, 407, 432, 434, 450, 452,
		458, 460, 521, 523, 523, 527, 544, 547, 558, 560, 589, 591, 606, 608, 636,
		638, 672, 674, 675, 677, 688, 697, 697, 699, 707, 710, 712, 717, 718, 720,
		724, 728, 732, 734, 734, 736, 738, 741, 741, 743, 745, 792, 792, 836, 836,
		875, 875, 1000, 1000, 1005, 1005, 1088, 1088, 24, 0, 39, 39, 97, 97, 148,
		148, 150, 150, 170, 170, 217, 219, 221, 221, 251, 282, 290, 293, 295, 297,
		300, 304, 324, 324, 459, 459, 673, 673, 689, 696, 736, 736, 803, 803, 806,
		835, 837, 874, 876, 999, 1001, 1004, 1006, 1087, 1089, 1107, 1123, 1123,
		8771, 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, 5329, 1, 0, 0, 0, 442,
		5331, 1, 0, 0, 0, 444, 5344, 1, 0, 0, 0, 446, 5355, 1, 0, 0, 0, 448, 5383,
		1, 0, 0, 0, 450, 5387, 1, 0, 0, 0, 452, 5408, 1, 0, 0, 0, 454, 5418, 1,
		0, 0, 0, 456, 5428, 1, 0, 0, 0, 458, 5468, 1, 0, 0, 0, 460, 5470, 1, 0,
		0, 0, 462, 5473, 1, 0, 0, 0, 464, 5573, 1, 0, 0, 0, 466, 5591, 1, 0, 0,
		0, 468, 5593, 1, 0, 0, 0, 470, 5597, 1, 0, 0, 0, 472, 5635, 1, 0, 0, 0,
		474, 5644, 1, 0, 0, 0, 476, 5650, 1, 0, 0, 0, 478, 5657, 1, 0, 0, 0, 480,
		5679, 1, 0, 0, 0, 482, 5681, 1, 0, 0, 0, 484, 5695, 1, 0, 0, 0, 486, 5701,
		1, 0, 0, 0, 488, 5757, 1, 0, 0, 0, 490, 5912, 1, 0, 0, 0, 492, 5924, 1,
		0, 0, 0, 494, 5939, 1, 0, 0, 0, 496, 5945, 1, 0, 0, 0, 498, 5964, 1, 0,
		0, 0, 500, 5974, 1, 0, 0, 0, 502, 5988, 1, 0, 0, 0, 504, 5990, 1, 0, 0,
		0, 506, 5993, 1, 0, 0, 0, 508, 6015, 1, 0, 0, 0, 510, 6027, 1, 0, 0, 0,
		512, 6033, 1, 0, 0, 0, 514, 6045, 1, 0, 0, 0, 516, 6049, 1, 0, 0, 0, 518,
		6051, 1, 0, 0, 0, 520, 6093, 1, 0, 0, 0, 522, 6100, 1, 0, 0, 0, 524, 6102,
		1, 0, 0, 0, 526, 6125, 1, 0, 0, 0, 528, 6131, 1, 0, 0, 0, 530, 6139, 1,
		0, 0, 0, 532, 6142, 1, 0, 0, 0, 534, 6145, 1, 0, 0, 0, 536, 6166, 1, 0,
		0, 0, 538, 6187, 1, 0, 0, 0, 540, 6195, 1, 0, 0, 0, 542, 6207, 1, 0, 0,
		0, 544, 6215, 1, 0, 0, 0, 546, 6253, 1, 0, 0, 0, 548, 6265, 1, 0, 0, 0,
		550, 6267, 1, 0, 0, 0, 552, 6273, 1, 0, 0, 0, 554, 6277, 1, 0, 0, 0, 556,
		6293, 1, 0, 0, 0, 558, 6306, 1, 0, 0, 0, 560, 6315, 1, 0, 0, 0, 562, 6317,
		1, 0, 0, 0, 564, 6324, 1, 0, 0, 0, 566, 6326, 1, 0, 0, 0, 568, 6332, 1,
		0, 0, 0, 570, 6336, 1, 0, 0, 0, 572, 6341, 1, 0, 0, 0, 574, 6343, 1, 0,
		0, 0, 576, 6345, 1, 0, 0, 0, 578, 6363, 1, 0, 0, 0, 580, 6379, 1, 0, 0,
		0, 582, 6383, 1, 0, 0, 0, 584, 6388, 1, 0, 0, 0, 586, 6399, 1, 0, 0, 0,
		588, 6404, 1, 0, 0, 0, 590, 6406, 1, 0, 0, 0, 592, 6410, 1, 0, 0, 0, 594,
		6435, 1, 0, 0, 0, 596, 6437, 1, 0, 0, 0, 598, 6440, 1, 0, 0, 0, 600, 6445,
		1, 0, 0, 0, 602, 6461, 1, 0, 0, 0, 604, 6589, 1, 0, 0, 0, 606, 6591, 1,
		0, 0, 0, 608, 6624, 1, 0, 0, 0, 610, 6629, 1, 0, 0, 0, 612, 6633, 1, 0,
		0, 0, 614, 6639, 1, 0, 0, 0, 616, 6647, 1, 0, 0, 0, 618, 6655, 1, 0, 0,
		0, 620, 6663, 1, 0, 0, 0, 622, 6671, 1, 0, 0, 0, 624, 6682, 1, 0, 0, 0,
		626, 6690, 1, 0, 0, 0, 628, 6698, 1, 0, 0, 0, 630, 6706, 1, 0, 0, 0, 632,
		6714, 1, 0, 0, 0, 634, 6748, 1, 0, 0, 0, 636, 6764, 1, 0, 0, 0, 638, 6768,
		1, 0, 0, 0, 640, 6770, 1, 0, 0, 0, 642, 6773, 1, 0, 0, 0, 644, 6777, 1,
		0, 0, 0, 646, 6783, 1, 0, 0, 0, 648, 6803, 1, 0, 0, 0, 650, 6984, 1, 0,
		0, 0, 652, 6986, 1, 0, 0, 0, 654, 7005, 1, 0, 0, 0, 656, 7007, 1, 0, 0,
		0, 658, 7070, 1, 0, 0, 0, 660, 7110, 1, 0, 0, 0, 662, 7112, 1, 0, 0, 0,
		664, 7121, 1, 0, 0, 0, 666, 7132, 1, 0, 0, 0, 668, 7134, 1, 0, 0, 0, 670,
		7137, 1, 0, 0, 0, 672, 7141, 1, 0, 0, 0, 674, 7143, 1, 0, 0, 0, 676, 7155,
		1, 0, 0, 0, 678, 7157, 1, 0, 0, 0, 680, 7191, 1, 0, 0, 0, 682, 7193, 1,
		0, 0, 0, 684, 7202, 1, 0, 0, 0, 686, 7220, 1, 0, 0, 0, 688, 7233, 1, 0,
		0, 0, 690, 7244, 1, 0, 0, 0, 692, 7362, 1, 0, 0, 0, 694, 7388, 1, 0, 0,
		0, 696, 7404, 1, 0, 0, 0, 698, 7413, 1, 0, 0, 0, 700, 7422, 1, 0, 0, 0,
		702, 7424, 1, 0, 0, 0, 704, 7426, 1, 0, 0, 0, 706, 7433, 1, 0, 0, 0, 708,
		7435, 1, 0, 0, 0, 710, 7437, 1, 0, 0, 0, 712, 7439, 1, 0, 0, 0, 714, 7441,
		1, 0, 0, 0, 716, 7443, 1, 0, 0, 0, 718, 7445, 1, 0, 0, 0, 720, 7447, 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, 1121, 0, 0, 726, 728, 5, 1121, 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,
		1121, 0, 0, 733, 735, 5, 1121, 0, 0, 734, 732, 1, 0, 0, 0, 734, 735, 1,
		0, 0, 0, 735, 737, 1, 0, 0, 0, 736, 738, 5, 1136, 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, 1121, 0, 0, 747, 749, 5,
		1121, 0, 0, 748, 746, 1, 0, 0, 0, 748, 749, 1, 0, 0, 0, 749, 750, 1, 0,
		0, 0, 750, 752, 5, 1136, 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, 1136, 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, 415, 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,
		605, 0, 0, 929, 936, 3, 66, 33, 0, 930, 931, 5, 118, 0, 0, 931, 933, 5,
		371, 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, 561, 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, 368, 0, 0, 942, 944, 5, 1148, 0, 0, 943, 941, 1, 0, 0, 0, 943,
		944, 1, 0, 0, 0, 944, 945, 1, 0, 0, 0, 945, 946, 5, 399, 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, 336, 0, 0, 970, 972, 5, 1124,
		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, 1124, 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, 475, 0,
		0, 986, 987, 5, 73, 0, 0, 987, 988, 3, 584, 292, 0, 988, 989, 5, 5, 0,
		0, 989, 990, 5, 659, 0, 0, 990, 996, 5, 1148, 0, 0, 991, 993, 5, 453, 0,
		0, 992, 994, 5, 1124, 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, 660, 0, 0, 999, 1001,
		5, 1124, 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, 572, 0, 0, 1006, 1008,
		5, 1124, 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, 528, 0, 0, 1013, 1015,
		5, 1124, 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, 674, 0, 0, 1020, 1019,
		1, 0, 0, 0, 1020, 1021, 1, 0, 0, 0, 1021, 1027, 1, 0, 0, 0, 1022, 1024,
		5, 368, 0, 0, 1023, 1025, 5, 1124, 0, 0, 1024, 1023, 1, 0, 0, 0, 1024,
		1025, 1, 0, 0, 0, 1025, 1026, 1, 0, 0, 0, 1026, 1028, 5, 1148, 0, 0, 1027,
		1022, 1, 0, 0, 0, 1027, 1028, 1, 0, 0, 0, 1028, 1029, 1, 0, 0, 0, 1029,
		1031, 5, 409, 0, 0, 1030, 1032, 5, 1124, 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,
		1133, 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, 1135, 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, 1134, 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, 335, 0, 0, 1066, 1065, 1, 0, 0, 0, 1066,
		1067, 1, 0, 0, 0, 1067, 1068, 1, 0, 0, 0, 1068, 1070, 5, 437, 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, 1133, 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, 1135, 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, 1134, 0, 0, 1085, 1086, 5, 594, 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, 596, 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, 1135, 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, 608, 0,
		0, 1112, 1113, 3, 584, 292, 0, 1113, 1114, 5, 67, 0, 0, 1114, 1115, 5,
		388, 0, 0, 1115, 1116, 5, 679, 0, 0, 1116, 1117, 7, 5, 0, 0, 1117, 1118,
		5, 541, 0, 0, 1118, 1119, 5, 1133, 0, 0, 1119, 1124, 3, 86, 43, 0, 1120,
		1121, 5, 1135, 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, 1134, 0,
		0, 1128, 39, 1, 0, 0, 0, 1129, 1131, 5, 33, 0, 0, 1130, 1132, 5, 649, 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, 1133, 0, 0, 1141, 1142, 5, 98, 0, 0, 1142, 1143, 3, 552, 276,
		0, 1143, 1144, 5, 1134, 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, 649, 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, 1135, 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, 649, 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, 1135, 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, 647, 0, 0, 1211, 1212, 3, 584, 292, 0, 1212, 1213,
		5, 5, 0, 0, 1213, 1214, 5, 389, 0, 0, 1214, 1218, 5, 1148, 0, 0, 1215,
		1216, 5, 428, 0, 0, 1216, 1217, 5, 1124, 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, 409, 0, 0, 1221, 1223, 5, 1124, 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, 647, 0, 0, 1229, 1230,
		3, 584, 292, 0, 1230, 1231, 5, 5, 0, 0, 1231, 1232, 5, 389, 0, 0, 1232,
		1233, 5, 1148, 0, 0, 1233, 1234, 5, 186, 0, 0, 1234, 1235, 5, 475, 0, 0,
		1235, 1236, 5, 73, 0, 0, 1236, 1242, 3, 584, 292, 0, 1237, 1239, 5, 423,
		0, 0, 1238, 1240, 5, 1124, 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, 453, 0, 0, 1245, 1247, 5, 1124, 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, 341, 0, 0, 1252, 1254, 5, 1124, 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, 501, 0, 0, 1259, 1261, 5, 1124, 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, 528, 0, 0, 1266, 1268, 5, 1124, 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, 674, 0, 0, 1273, 1272, 1, 0, 0, 0, 1273,
		1274, 1, 0, 0, 0, 1274, 1280, 1, 0, 0, 0, 1275, 1277, 5, 368, 0, 0, 1276,
		1278, 5, 1124, 0, 0, 1277, 1276, 1, 0, 0, 0, 1277, 1278, 1, 0, 0, 0, 1278,
		1279, 1, 0, 0, 0, 1279, 1281, 5, 1148, 0, 0, 1280, 1275, 1, 0, 0, 0, 1280,
		1281, 1, 0, 0, 0, 1281, 1282, 1, 0, 0, 0, 1282, 1284, 5, 409, 0, 0, 1283,
		1285, 5, 1124, 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, 600, 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,
		571, 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, 1133, 0, 0, 1318, 1323, 3, 54, 27, 0, 1319,
		1320, 5, 1135, 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, 1134, 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, 1133,
		0, 0, 1332, 1333, 3, 10, 5, 0, 1333, 1336, 5, 1134, 0, 0, 1334, 1335, 5,
		1135, 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, 336, 0, 0, 1347,
		1348, 5, 1124, 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, 606, 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, 671, 0, 0, 1360, 1365, 3, 550, 275, 0, 1361, 1362, 5, 1133,
		0, 0, 1362, 1363, 3, 616, 308, 0, 1363, 1364, 5, 1134, 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, 1133, 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, 1134, 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, 1124, 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, 1124, 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,
		405, 0, 0, 1412, 1414, 5, 1124, 0, 0, 1413, 1412, 1, 0, 0, 0, 1413, 1414,
		1, 0, 0, 0, 1414, 1415, 1, 0, 0, 0, 1415, 1423, 5, 1148, 0, 0, 1416, 1417,
		5, 134, 0, 0, 1417, 1419, 5, 538, 0, 0, 1418, 1420, 5, 1124, 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, 841, 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, 1133, 0, 0, 1433, 1435, 5, 1134, 0, 0, 1434,
		1432, 1, 0, 0, 0, 1434, 1435, 1, 0, 0, 0, 1435, 63, 1, 0, 0, 0, 1436, 1437,
		5, 392, 0, 0, 1437, 1440, 5, 1124, 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, 338, 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, 417, 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, 630,
		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,
		408, 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,
		315, 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, 1120, 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, 240, 0,
		0, 1495, 1506, 5, 241, 0, 0, 1496, 1506, 5, 242, 0, 0, 1497, 1506, 5, 243,
		0, 0, 1498, 1506, 5, 244, 0, 0, 1499, 1506, 5, 245, 0, 0, 1500, 1506, 5,
		246, 0, 0, 1501, 1506, 5, 247, 0, 0, 1502, 1506, 5, 248, 0, 0, 1503, 1506,
		5, 249, 0, 0, 1504, 1506, 5, 250, 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, 403, 0, 0, 1508, 1513, 5, 396, 0, 0, 1509, 1510,
		5, 396, 0, 0, 1510, 1511, 5, 118, 0, 0, 1511, 1513, 5, 614, 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, 467, 0, 0, 1518, 1520, 5, 1124, 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, 547, 0, 0, 1525, 1540, 3, 584, 292, 0, 1526, 1527, 5,
		368, 0, 0, 1527, 1540, 5, 1148, 0, 0, 1528, 1540, 7, 15, 0, 0, 1529, 1531,
		5, 875, 0, 0, 1530, 1532, 5, 1124, 0, 0, 1531, 1530, 1, 0, 0, 0, 1531,
		1532, 1, 0, 0, 0, 1532, 1533, 1, 0, 0, 0, 1533, 1540, 5, 1148, 0, 0, 1534,
		1536, 5, 1000, 0, 0, 1535, 1537, 5, 1124, 0, 0, 1536, 1535, 1, 0, 0, 0,
		1536, 1537, 1, 0, 0, 0, 1537, 1538, 1, 0, 0, 0, 1538, 1540, 5, 1148, 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, 368, 0, 0, 1551, 1574, 5, 1148, 0, 0, 1552,
		1553, 5, 468, 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, 381, 0, 0, 1559, 1569, 5, 160,
		0, 0, 1560, 1561, 5, 521, 0, 0, 1561, 1569, 5, 160, 0, 0, 1562, 1563, 5,
		135, 0, 0, 1563, 1564, 5, 160, 0, 0, 1564, 1569, 5, 388, 0, 0, 1565, 1566,
		5, 112, 0, 0, 1566, 1567, 5, 160, 0, 0, 1567, 1569, 5, 388, 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, 606, 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, 446, 0, 0, 1576,
		1590, 5, 1148, 0, 0, 1577, 1578, 5, 39, 0, 0, 1578, 1590, 5, 1148, 0, 0,
		1579, 1580, 5, 665, 0, 0, 1580, 1590, 5, 1148, 0, 0, 1581, 1582, 5, 551,
		0, 0, 1582, 1590, 5, 1148, 0, 0, 1583, 1584, 5, 617, 0, 0, 1584, 1590,
		5, 1148, 0, 0, 1585, 1586, 5, 542, 0, 0, 1586, 1590, 5, 1148, 0, 0, 1587,
		1588, 5, 557, 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, 1133, 0, 0, 1592, 1597, 3, 90, 45,
		0, 1593, 1594, 5, 1135, 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,
		1134, 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, 673, 0, 0, 1632,
		1682, 5, 459, 0, 0, 1633, 1638, 5, 342, 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, 368, 0, 0, 1648, 1682, 5, 1148, 0, 0, 1649, 1650,
		5, 366, 0, 0, 1650, 1682, 7, 17, 0, 0, 1651, 1652, 5, 636, 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, 1133, 0, 0, 1662, 1663, 3, 688,
		344, 0, 1663, 1665, 5, 1134, 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, 669, 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, 1133, 0, 0, 1678, 1679, 3, 688, 344, 0, 1679, 1680, 5, 1134,
		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, 1133, 0, 0, 1749, 1750, 3, 688,
		344, 0, 1750, 1751, 5, 1134, 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, 521, 0, 0, 1789, 1793, 5, 333,
		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, 409, 0, 0, 1825, 1827, 5, 1124, 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, 875, 0, 0, 1832, 1834, 5, 1124, 0, 0,
		1833, 1832, 1, 0, 0, 0, 1833, 1834, 1, 0, 0, 0, 1834, 1835, 1, 0, 0, 0,
		1835, 2010, 5, 1148, 0, 0, 1836, 1838, 5, 341, 0, 0, 1837, 1839, 5, 1124,
		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, 342, 0, 0, 1842, 1844,
		5, 1124, 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, 343, 0, 0, 1847,
		1849, 5, 1124, 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, 1124, 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,
		1124, 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, 1124, 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, 368, 0, 0, 1876, 1878, 5, 1124, 0, 0, 1877, 1876, 1, 0, 0, 0, 1877,
		1878, 1, 0, 0, 0, 1878, 1879, 1, 0, 0, 0, 1879, 2010, 5, 1148, 0, 0, 1880,
		1882, 5, 373, 0, 0, 1881, 1883, 5, 1124, 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, 376, 0, 0, 1886, 1888, 5, 1124, 0, 0, 1887, 1886, 1, 0,
		0, 0, 1887, 1888, 1, 0, 0, 0, 1888, 1889, 1, 0, 0, 0, 1889, 2010, 5, 1148,
		0, 0, 1890, 1891, 7, 26, 0, 0, 1891, 1893, 5, 395, 0, 0, 1892, 1894, 5,
		1124, 0, 0, 1893, 1892, 1, 0, 0, 0, 1893, 1894, 1, 0, 0, 0, 1894, 1895,
		1, 0, 0, 0, 1895, 2010, 5, 1148, 0, 0, 1896, 1898, 5, 393, 0, 0, 1897,
		1899, 5, 1124, 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, 405, 0, 0, 1902,
		1904, 5, 1124, 0, 0, 1903, 1902, 1, 0, 0, 0, 1903, 1904, 1, 0, 0, 0, 1904,
		1905, 1, 0, 0, 0, 1905, 2010, 5, 1148, 0, 0, 1906, 1908, 7, 27, 0, 0, 1907,
		1909, 5, 1124, 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, 1124, 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, 406, 0, 0,
		1917, 1919, 5, 1124, 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, 395, 0, 0, 1923, 1925, 5, 1124, 0, 0, 1924, 1923,
		1, 0, 0, 0, 1924, 1925, 1, 0, 0, 0, 1925, 1926, 1, 0, 0, 0, 1926, 2010,
		5, 1148, 0, 0, 1927, 1929, 5, 455, 0, 0, 1928, 1930, 5, 1124, 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, 467, 0, 0, 1933, 1935, 5, 1124, 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, 500, 0, 0, 1938, 1940, 5, 1124,
		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, 510, 0, 0, 1943, 1945,
		5, 1124, 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, 543, 0, 0, 1948,
		1950, 5, 1124, 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, 551, 0, 0, 1953,
		1955, 5, 1124, 0, 0, 1954, 1953, 1, 0, 0, 0, 1954, 1955, 1, 0, 0, 0, 1955,
		1956, 1, 0, 0, 0, 1956, 2010, 5, 1148, 0, 0, 1957, 1959, 5, 602, 0, 0,
		1958, 1960, 5, 1124, 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, 629,
		0, 0, 1963, 2010, 5, 653, 0, 0, 1964, 1966, 5, 1000, 0, 0, 1965, 1967,
		5, 1124, 0, 0, 1966, 1965, 1, 0, 0, 0, 1966, 1967, 1, 0, 0, 0, 1967, 1968,
		1, 0, 0, 0, 1968, 2010, 5, 1148, 0, 0, 1969, 1971, 5, 631, 0, 0, 1970,
		1972, 5, 1124, 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, 632, 0, 0, 1975,
		1977, 5, 1124, 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, 633, 0, 0, 1980,
		1982, 5, 1124, 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, 647, 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, 648, 0, 0, 1993, 1994, 5, 1124, 0, 0, 1994, 2010,
		3, 108, 54, 0, 1995, 2010, 3, 110, 55, 0, 1996, 1998, 5, 654, 0, 0, 1997,
		1999, 5, 1124, 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, 1124, 0, 0, 2003, 2002, 1, 0, 0, 0, 2003, 2004, 1, 0, 0, 0, 2004,
		2005, 1, 0, 0, 0, 2005, 2006, 5, 1133, 0, 0, 2006, 2007, 3, 620, 310, 0,
		2007, 2008, 5, 1134, 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, 636, 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, 550, 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, 641, 0, 0, 2024, 2025, 5, 19, 0, 0, 2025, 2028,
		3, 116, 58, 0, 2026, 2027, 5, 642, 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, 1133, 0, 0, 2033, 2038, 3, 118, 59, 0, 2034, 2035, 5, 1135, 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, 1134, 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, 443, 0, 0, 2049, 2050,
		5, 1133, 0, 0, 2050, 2051, 3, 688, 344, 0, 2051, 2052, 5, 1134, 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, 336, 0, 0, 2058, 2059, 5, 1124, 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, 1133, 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, 1134,
		0, 0, 2067, 2077, 5, 133, 0, 0, 2068, 2069, 5, 1133, 0, 0, 2069, 2070,
		3, 688, 344, 0, 2070, 2071, 5, 1134, 0, 0, 2071, 2078, 1, 0, 0, 0, 2072,
		2073, 5, 365, 0, 0, 2073, 2074, 5, 1133, 0, 0, 2074, 2075, 3, 616, 308,
		0, 2075, 2076, 5, 1134, 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, 473,
		0, 0, 2080, 2081, 5, 1133, 0, 0, 2081, 2082, 3, 688, 344, 0, 2082, 2083,
		5, 1134, 0, 0, 2083, 2090, 1, 0, 0, 0, 2084, 2085, 5, 365, 0, 0, 2085,
		2086, 5, 1133, 0, 0, 2086, 2087, 3, 616, 308, 0, 2087, 2088, 5, 1134, 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, 443, 0, 0, 2097, 2098, 5,
		1133, 0, 0, 2098, 2099, 3, 688, 344, 0, 2099, 2100, 5, 1134, 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, 336, 0, 0, 2106, 2107, 5, 1124, 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, 1133, 0, 0, 2111, 2112, 3, 616, 308, 0, 2112, 2113, 5, 1134,
		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, 471, 0, 0, 2120, 2121,
		5, 651, 0, 0, 2121, 2122, 5, 1133, 0, 0, 2122, 2127, 3, 120, 60, 0, 2123,
		2124, 5, 1135, 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, 1134, 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, 1133, 0, 0, 2138, 2143, 3,
		124, 62, 0, 2139, 2140, 5, 1135, 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, 1134, 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, 471, 0,
		0, 2154, 2155, 5, 651, 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, 1133, 0, 0, 2163, 2168, 3, 124, 62, 0, 2164,
		2165, 5, 1135, 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, 1134, 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, 1133, 0, 0, 2180, 2185, 3, 120, 60, 0, 2181, 2182, 5, 1135, 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, 1134, 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, 1133, 0, 0, 2196, 2201, 3, 124, 62, 0, 2197, 2198, 5, 1135,
		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, 1134, 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, 1133, 0, 0,
		2213, 2218, 3, 122, 61, 0, 2214, 2215, 5, 1135, 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, 1134, 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, 1133, 0, 0, 2229, 2234, 3, 124, 62, 0, 2230, 2231, 5, 1135, 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, 1134, 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, 1133, 0, 0, 2250, 2255, 3, 124, 62, 0, 2251, 2252, 5,
		1135, 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, 1134, 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, 1133, 0, 0, 2270,
		2273, 3, 120, 60, 0, 2271, 2272, 5, 1135, 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, 1134,
		0, 0, 2278, 123, 1, 0, 0, 0, 2279, 2280, 5, 641, 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, 636, 0, 0, 2291, 2290, 1, 0, 0, 0, 2291, 2292, 1, 0, 0, 0, 2292, 2293,
		1, 0, 0, 0, 2293, 2295, 5, 409, 0, 0, 2294, 2296, 5, 1124, 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, 368, 0, 0, 2299, 2301, 5, 1124, 0,
		0, 2300, 2299, 1, 0, 0, 0, 2300, 2301, 1, 0, 0, 0, 2301, 2302, 1, 0, 0,
		0, 2302, 2336, 5, 1148, 0, 0, 2303, 2304, 5, 388, 0, 0, 2304, 2306, 5,
		395, 0, 0, 2305, 2307, 5, 1124, 0, 0, 2306, 2305, 1, 0, 0, 0, 2306, 2307,
		1, 0, 0, 0, 2307, 2308, 1, 0, 0, 0, 2308, 2336, 5, 1148, 0, 0, 2309, 2310,
		5, 81, 0, 0, 2310, 2312, 5, 395, 0, 0, 2311, 2313, 5, 1124, 0, 0, 2312,
		2311, 1, 0, 0, 0, 2312, 2313, 1, 0, 0, 0, 2313, 2314, 1, 0, 0, 0, 2314,
		2336, 5, 1148, 0, 0, 2315, 2317, 5, 500, 0, 0, 2316, 2318, 5, 1124, 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, 510, 0, 0, 2321, 2323, 5,
		1124, 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, 647, 0, 0, 2326,
		2328, 5, 1124, 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, 528, 0, 0,
		2331, 2333, 5, 1124, 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, 664, 0, 0, 2351, 2352, 5, 388, 0, 0, 2352, 2353, 5, 395, 0, 0, 2353,
		2354, 5, 516, 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, 415, 0, 0, 2362, 2366, 3, 550, 275, 0,
		2363, 2364, 5, 118, 0, 0, 2364, 2365, 5, 605, 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, 371, 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, 561, 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, 368, 0, 0, 2385, 2387, 5, 1148, 0, 0, 2386, 2384, 1, 0, 0, 0,
		2386, 2387, 1, 0, 0, 0, 2387, 2390, 1, 0, 0, 0, 2388, 2389, 5, 399, 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, 437,
		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, 457, 0, 0, 2403, 2404, 5, 599, 0, 0, 2404, 2405,
		5, 791, 0, 0, 2405, 2406, 5, 477, 0, 0, 2406, 2407, 5, 91, 0, 0, 2407,
		135, 1, 0, 0, 0, 2408, 2409, 5, 7, 0, 0, 2409, 2410, 5, 475, 0, 0, 2410,
		2411, 5, 73, 0, 0, 2411, 2412, 3, 584, 292, 0, 2412, 2413, 5, 5, 0, 0,
		2413, 2414, 5, 659, 0, 0, 2414, 2420, 5, 1148, 0, 0, 2415, 2417, 5, 453,
		0, 0, 2416, 2418, 5, 1124, 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, 674, 0, 0, 2423, 2422, 1, 0, 0, 0, 2423, 2424, 1, 0, 0, 0, 2424, 2425,
		1, 0, 0, 0, 2425, 2427, 5, 409, 0, 0, 2426, 2428, 5, 1124, 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, 608, 0, 0, 2442, 2443, 3, 584,
		292, 0, 2443, 2444, 5, 541, 0, 0, 2444, 2445, 5, 1133, 0, 0, 2445, 2450,
		3, 86, 43, 0, 2446, 2447, 5, 1135, 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, 1134, 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, 1135, 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, 647, 0, 0, 2482, 2483,
		3, 584, 292, 0, 2483, 2484, 7, 33, 0, 0, 2484, 2485, 5, 389, 0, 0, 2485,
		2489, 5, 1148, 0, 0, 2486, 2487, 5, 453, 0, 0, 2487, 2488, 5, 1124, 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, 674, 0, 0, 2492, 2491, 1,
		0, 0, 0, 2492, 2493, 1, 0, 0, 0, 2493, 2494, 1, 0, 0, 0, 2494, 2496, 5,
		409, 0, 0, 2495, 2497, 5, 1124, 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, 336, 0, 0, 2502, 2503,
		5, 1124, 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, 606, 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, 671, 0, 0, 2515, 2520, 3, 550, 275, 0, 2516, 2517, 5, 1133, 0,
		0, 2517, 2518, 3, 616, 308, 0, 2518, 2519, 5, 1134, 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, 1135, 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, 430, 0,
		0, 2549, 2550, 5, 334, 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,
		1133, 0, 0, 2558, 2559, 3, 584, 292, 0, 2559, 2566, 3, 92, 46, 0, 2560,
		2561, 5, 1135, 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, 1134, 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, 1133, 0, 0, 2673, 2674, 3, 688,
		344, 0, 2674, 2675, 5, 1134, 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, 1133, 0, 0, 2695, 2696, 3, 688, 344, 0, 2696, 2697, 5,
		1134, 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, 1133, 0, 0, 2715, 2716, 3, 688, 344, 0, 2716, 2717, 5, 1134, 0,
		0, 2717, 2884, 1, 0, 0, 0, 2718, 2720, 5, 336, 0, 0, 2719, 2721, 5, 1124,
		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, 430, 0, 0, 2743, 2744, 5, 334, 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, 1124, 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, 512,
		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, 430, 0, 0, 2765, 2766, 5, 334, 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, 1133, 0, 0, 2801, 2802, 3, 688,
		344, 0, 2802, 2803, 5, 1134, 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, 396, 0, 0,
		2822, 2884, 5, 92, 0, 0, 2823, 2824, 5, 403, 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, 841, 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, 1124, 0, 0, 2854, 2858,
		3, 568, 284, 0, 2855, 2856, 5, 27, 0, 0, 2856, 2857, 5, 1124, 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, 397, 0, 0, 2861, 2884, 5, 647, 0, 0, 2862,
		2863, 5, 450, 0, 0, 2863, 2884, 5, 647, 0, 0, 2864, 2884, 5, 66, 0, 0,
		2865, 2866, 7, 37, 0, 0, 2866, 2884, 5, 668, 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, 1133, 0, 0, 2872, 2877, 3, 90,
		45, 0, 2873, 2874, 5, 1135, 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, 1134, 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, 1133, 0, 0, 2888, 2893, 3, 118, 59,
		0, 2889, 2890, 5, 1135, 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,
		1134, 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, 397, 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, 647, 0, 0, 2908, 2909, 5, 450, 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,
		647, 0, 0, 2915, 2916, 5, 656, 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, 363, 0, 0, 2922, 2923,
		5, 129, 0, 0, 2923, 2984, 3, 590, 295, 0, 2924, 2925, 5, 579, 0, 0, 2925,
		2926, 5, 129, 0, 0, 2926, 2927, 3, 616, 308, 0, 2927, 2928, 5, 87, 0, 0,
		2928, 2929, 5, 1133, 0, 0, 2929, 2934, 3, 118, 59, 0, 2930, 2931, 5, 1135,
		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, 1134, 0, 0, 2938, 2984,
		1, 0, 0, 0, 2939, 2940, 5, 418, 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, 668, 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, 569, 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, 580, 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, 578, 0, 0, 2980, 2984, 5, 549, 0, 0, 2981, 2982, 5, 664,
		0, 0, 2982, 2984, 5, 549, 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, 415, 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, 336, 0, 0, 3008, 3010, 5, 1124,
		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,
		1124, 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, 475, 0, 0, 3024, 3025, 5, 73, 0, 0, 3025, 3026,
		3, 584, 292, 0, 3026, 3027, 5, 409, 0, 0, 3027, 3028, 5, 1124, 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, 437,
		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, 608, 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, 649, 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, 647, 0, 0, 3065, 3071, 3, 584, 292, 0,
		3066, 3068, 5, 409, 0, 0, 3067, 3069, 5, 1124, 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, 671, 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, 1135, 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, 596,
		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, 1135, 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, 596, 0, 0, 3112, 3123, 5, 529, 0, 0,
		3113, 3123, 5, 6, 0, 0, 3114, 3119, 3, 554, 277, 0, 3115, 3116, 5, 1135,
		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, 1135, 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, 596, 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, 1135, 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, 656, 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, 1133, 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, 1134, 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, 399, 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, 1133, 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, 1134, 0, 0, 3204, 3198, 1, 0, 0, 0, 3204,
		3205, 1, 0, 0, 0, 3205, 3229, 1, 0, 0, 0, 3206, 3208, 5, 1133, 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, 1134, 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, 1135, 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, 401, 0, 0, 3233, 3234, 5, 91,
		0, 0, 3234, 3235, 5, 184, 0, 0, 3235, 3240, 3, 208, 104, 0, 3236, 3237,
		5, 1135, 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, 388, 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, 474, 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, 1148, 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, 1133, 0, 0, 3263, 3264, 3, 616,
		308, 0, 3264, 3265, 5, 1134, 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, 1133, 0, 0, 3296, 3301, 3, 210, 105, 0, 3297, 3298,
		5, 1135, 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, 1134, 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, 1135, 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, 682, 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,
		474, 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, 1148, 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, 601, 0, 0, 3341, 3342, 5, 448, 0, 0, 3342,
		3343, 5, 19, 0, 0, 3343, 3344, 5, 1126, 0, 0, 3344, 3345, 5, 1148, 0, 0,
		3345, 3347, 5, 1125, 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,
		1133, 0, 0, 3355, 3360, 3, 210, 105, 0, 3356, 3357, 5, 1135, 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, 1134, 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, 1135, 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, 1133, 0, 0, 3388, 3389, 3, 616, 308, 0, 3389,
		3390, 5, 1134, 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, 1133, 0, 0, 3394,
		3395, 3, 616, 308, 0, 3395, 3396, 5, 1134, 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, 1135, 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, 1135, 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, 1133,
		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, 1134, 0, 0, 3488, 3489,
		5, 1135, 0, 0, 3489, 3491, 5, 1133, 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, 1134, 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, 1133, 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, 1134,
		0, 0, 3506, 3507, 5, 1135, 0, 0, 3507, 3509, 5, 1133, 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, 1134, 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, 1124, 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, 1159, 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, 610, 0, 0, 3534, 3536, 5, 511, 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, 568, 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, 1133, 0, 0, 3557, 3558, 3, 616, 308, 0, 3558, 3559, 5, 1134, 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, 568, 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, 1132, 0, 0, 3585, 3587, 5, 1117, 0, 0, 3586, 3584, 1, 0, 0, 0, 3586,
		3587, 1, 0, 0, 0, 3587, 3596, 1, 0, 0, 0, 3588, 3589, 5, 1135, 0, 0, 3589,
		3592, 3, 552, 276, 0, 3590, 3591, 5, 1132, 0, 0, 3591, 3593, 5, 1117, 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, 1132, 0, 0, 3605, 3607, 5, 1117, 0, 0, 3606, 3604, 1, 0, 0, 0, 3606,
		3607, 1, 0, 0, 0, 3607, 3616, 1, 0, 0, 0, 3608, 3609, 5, 1135, 0, 0, 3609,
		3612, 3, 552, 276, 0, 3610, 3611, 5, 1132, 0, 0, 3611, 3613, 5, 1117, 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, 442, 0, 0, 3629, 3630, 3, 552, 276, 0, 3630, 3635, 5, 539, 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, 442, 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, 1133, 0, 0, 3643, 3644, 3,
		628, 314, 0, 3644, 3645, 5, 1134, 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, 442, 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, 442, 0, 0, 3670,
		3671, 3, 552, 276, 0, 3671, 3672, 5, 361, 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, 1135, 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, 1135, 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, 1135, 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, 1135, 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, 1133, 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, 1134, 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, 1133, 0, 0, 3772, 3773, 3, 616, 308, 0, 3773,
		3774, 5, 1134, 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, 1135, 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, 1133,
		0, 0, 3795, 3796, 3, 200, 100, 0, 3796, 3797, 5, 1134, 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, 1133, 0, 0, 3806, 3807, 3, 234, 117, 0, 3807,
		3808, 5, 1134, 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, 1133, 0, 0, 3818, 3819, 3, 616, 308, 0,
		3819, 3820, 5, 1134, 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, 1133, 0,
		0, 3881, 3882, 3, 616, 308, 0, 3882, 3883, 5, 1134, 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, 1133, 0, 0, 3887, 3888, 3, 252, 126, 0, 3888, 3889,
		5, 1134, 0, 0, 3889, 3895, 1, 0, 0, 0, 3890, 3891, 5, 1133, 0, 0, 3891,
		3892, 3, 248, 124, 0, 3892, 3893, 5, 1134, 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, 1133, 0, 0, 3897, 3898, 3, 254, 127, 0, 3898, 3899, 5, 1134,
		0, 0, 3899, 3905, 1, 0, 0, 0, 3900, 3901, 5, 1133, 0, 0, 3901, 3902, 3,
		250, 125, 0, 3902, 3903, 5, 1134, 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, 1133, 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, 1134, 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, 278, 0, 0, 4021, 4022, 5, 1133, 0, 0, 4022, 4023, 5, 1148, 0, 0, 4023,
		4024, 5, 1135, 0, 0, 4024, 4025, 5, 1148, 0, 0, 4025, 4026, 5, 365, 0,
		0, 4026, 4027, 5, 1133, 0, 0, 4027, 4028, 3, 264, 132, 0, 4028, 4029, 5,
		1134, 0, 0, 4029, 4034, 5, 1134, 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, 1135, 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, 284, 0, 0, 4047, 4059, 3, 604, 302, 0, 4048, 4049, 5, 285,
		0, 0, 4049, 4051, 5, 1148, 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, 285, 0, 0, 4058, 4060,
		5, 1148, 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, 283, 0, 0, 4064, 4066, 5, 285, 0, 0, 4065, 4064,
		1, 0, 0, 0, 4065, 4066, 1, 0, 0, 0, 4066, 4067, 1, 0, 0, 0, 4067, 4068,
		5, 1148, 0, 0, 4068, 4069, 5, 365, 0, 0, 4069, 4070, 5, 1133, 0, 0, 4070,
		4071, 3, 264, 132, 0, 4071, 4072, 5, 1134, 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, 411, 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, 411, 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, 411, 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, 625, 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, 1117, 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, 1135, 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, 1132, 0, 0, 4116, 4117, 5, 1117, 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, 1159, 0, 0, 4133, 4135,
		5, 1108, 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, 1135, 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, 400,
		0, 0, 4156, 4182, 5, 1148, 0, 0, 4157, 4158, 5, 87, 0, 0, 4158, 4159, 5,
		127, 0, 0, 4159, 4163, 5, 1148, 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, 1148, 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,
		1148, 0, 0, 4192, 4193, 5, 58, 0, 0, 4193, 4194, 5, 19, 0, 0, 4194, 4196,
		5, 1148, 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, 1148, 0, 0, 4200, 4201, 5, 173, 0, 0, 4201,
		4202, 5, 19, 0, 0, 4202, 4204, 5, 1148, 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, 1135, 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, 598, 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, 676, 0, 0, 4231,
		4232, 3, 666, 333, 0, 4232, 4233, 5, 12, 0, 0, 4233, 4234, 5, 1133, 0,
		0, 4234, 4235, 3, 664, 332, 0, 4235, 4245, 5, 1134, 0, 0, 4236, 4237, 5,
		1135, 0, 0, 4237, 4238, 3, 666, 333, 0, 4238, 4239, 5, 12, 0, 0, 4239,
		4240, 5, 1133, 0, 0, 4240, 4241, 3, 664, 332, 0, 4241, 4242, 5, 1134, 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, 1135, 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, 532, 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, 629, 0,
		0, 4271, 4280, 5, 653, 0, 0, 4272, 4277, 3, 320, 160, 0, 4273, 4274, 5,
		1135, 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, 344, 0, 0, 4283, 4285,
		5, 678, 0, 0, 4284, 4283, 1, 0, 0, 0, 4284, 4285, 1, 0, 0, 0, 4285, 301,
		1, 0, 0, 0, 4286, 4288, 5, 369, 0, 0, 4287, 4289, 5, 678, 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, 521, 0, 0, 4292, 4291, 1, 0, 0, 0, 4292, 4293,
		1, 0, 0, 0, 4293, 4294, 1, 0, 0, 0, 4294, 4296, 5, 353, 0, 0, 4295, 4290,
		1, 0, 0, 0, 4295, 4296, 1, 0, 0, 0, 4296, 4301, 1, 0, 0, 0, 4297, 4299,
		5, 521, 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, 597, 0, 0, 4304, 4306,
		5, 678, 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, 521, 0, 0, 4309, 4308,
		1, 0, 0, 0, 4309, 4310, 1, 0, 0, 0, 4310, 4311, 1, 0, 0, 0, 4311, 4313,
		5, 353, 0, 0, 4312, 4307, 1, 0, 0, 0, 4312, 4313, 1, 0, 0, 0, 4313, 4318,
		1, 0, 0, 0, 4314, 4316, 5, 521, 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, 604, 0, 0, 4321, 4322, 3, 584, 292, 0, 4322, 307, 1, 0, 0, 0, 4323,
		4325, 5, 597, 0, 0, 4324, 4326, 5, 678, 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, 604, 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, 604, 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, 1135, 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, 742, 0, 0, 4352, 315, 1, 0, 0, 0, 4353, 4354, 5, 153, 0, 0, 4354, 4355,
		5, 340, 0, 0, 4355, 4356, 5, 1124, 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, 653, 0, 0, 4363, 4368, 3, 326, 163, 0, 4364, 4365, 5, 1135, 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,
		377, 0, 0, 4373, 4379, 5, 616, 0, 0, 4374, 4375, 5, 134, 0, 0, 4375, 4379,
		5, 193, 0, 0, 4376, 4377, 5, 134, 0, 0, 4377, 4379, 5, 538, 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, 474, 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, 464, 0, 0, 4400, 4401, 5, 472, 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, 538, 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, 799, 0, 0, 4409, 4416, 5, 134, 0, 0, 4410, 4411, 5,
		134, 0, 0, 4411, 4416, 5, 800, 0, 0, 4412, 4413, 5, 134, 0, 0, 4413, 4416,
		5, 801, 0, 0, 4414, 4416, 5, 802, 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, 477, 0, 0, 4419, 4420,
		5, 175, 0, 0, 4420, 4425, 3, 348, 174, 0, 4421, 4422, 5, 1135, 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, 588, 0, 0, 4433, 4434, 5, 429, 0, 0, 4434, 4439, 3, 358, 179,
		0, 4435, 4436, 5, 1135, 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, 476, 0, 0, 4445, 4446,
		5, 175, 0, 0, 4446, 4450, 5, 1148, 0, 0, 4447, 4448, 5, 15, 0, 0, 4448,
		4450, 5, 1148, 0, 0, 4449, 4445, 1, 0, 0, 0, 4449, 4447, 1, 0, 0, 0, 4450,
		335, 1, 0, 0, 0, 4451, 4452, 5, 589, 0, 0, 4452, 4453, 5, 477, 0, 0, 4453,
		337, 1, 0, 0, 0, 4454, 4455, 5, 589, 0, 0, 4455, 4457, 5, 614, 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, 629, 0, 0, 4463,
		4472, 5, 614, 0, 0, 4464, 4469, 3, 362, 181, 0, 4465, 4466, 5, 1135, 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, 663, 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, 635, 0, 0, 4488, 4497, 5, 614, 0, 0, 4489, 4494, 3, 362, 181, 0, 4490,
		4491, 5, 1135, 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, 629, 0, 0,
		4500, 4501, 5, 441, 0, 0, 4501, 345, 1, 0, 0, 0, 4502, 4503, 5, 635, 0,
		0, 4503, 4504, 5, 441, 0, 0, 4504, 347, 1, 0, 0, 0, 4505, 4506, 3, 350,
		175, 0, 4506, 4507, 5, 1124, 0, 0, 4507, 4508, 5, 1148, 0, 0, 4508, 4535,
		1, 0, 0, 0, 4509, 4510, 3, 352, 176, 0, 4510, 4511, 5, 1124, 0, 0, 4511,
		4512, 3, 590, 295, 0, 4512, 4535, 1, 0, 0, 0, 4513, 4514, 3, 354, 177,
		0, 4514, 4515, 5, 1124, 0, 0, 4515, 4516, 7, 24, 0, 0, 4516, 4535, 1, 0,
		0, 0, 4517, 4518, 5, 481, 0, 0, 4518, 4519, 5, 1124, 0, 0, 4519, 4535,
		5, 1151, 0, 0, 4520, 4521, 5, 449, 0, 0, 4521, 4522, 5, 1124, 0, 0, 4522,
		4531, 5, 1133, 0, 0, 4523, 4528, 3, 584, 292, 0, 4524, 4525, 5, 1135, 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, 1134, 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, 355, 0, 0, 4544, 4545, 5, 1148, 0, 0, 4545, 357,
		1, 0, 0, 0, 4546, 4547, 5, 581, 0, 0, 4547, 4548, 5, 1124, 0, 0, 4548,
		4549, 5, 1133, 0, 0, 4549, 4550, 3, 616, 308, 0, 4550, 4551, 5, 1134, 0,
		0, 4551, 4596, 1, 0, 0, 0, 4552, 4553, 5, 583, 0, 0, 4553, 4554, 5, 1124,
		0, 0, 4554, 4555, 5, 1133, 0, 0, 4555, 4556, 3, 616, 308, 0, 4556, 4557,
		5, 1134, 0, 0, 4557, 4596, 1, 0, 0, 0, 4558, 4559, 5, 582, 0, 0, 4559,
		4560, 5, 1124, 0, 0, 4560, 4561, 5, 1133, 0, 0, 4561, 4562, 3, 620, 310,
		0, 4562, 4563, 5, 1134, 0, 0, 4563, 4596, 1, 0, 0, 0, 4564, 4565, 5, 584,
		0, 0, 4565, 4566, 5, 1124, 0, 0, 4566, 4567, 5, 1133, 0, 0, 4567, 4568,
		3, 620, 310, 0, 4568, 4569, 5, 1134, 0, 0, 4569, 4596, 1, 0, 0, 0, 4570,
		4571, 5, 586, 0, 0, 4571, 4572, 5, 1124, 0, 0, 4572, 4573, 5, 1133, 0,
		0, 4573, 4574, 3, 630, 315, 0, 4574, 4575, 5, 1134, 0, 0, 4575, 4596, 1,
		0, 0, 0, 4576, 4577, 5, 587, 0, 0, 4577, 4578, 5, 1124, 0, 0, 4578, 4579,
		5, 1133, 0, 0, 4579, 4580, 3, 630, 315, 0, 4580, 4581, 5, 1134, 0, 0, 4581,
		4596, 1, 0, 0, 0, 4582, 4583, 5, 585, 0, 0, 4583, 4584, 5, 1124, 0, 0,
		4584, 4585, 5, 1133, 0, 0, 4585, 4590, 3, 360, 180, 0, 4586, 4587, 5, 1135,
		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, 1134, 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, 1133, 0, 0, 4598, 4599, 3, 552, 276, 0, 4599, 4600, 5, 1135, 0, 0, 4600,
		4601, 3, 552, 276, 0, 4601, 4602, 5, 1134, 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, 1124, 0, 0, 4607, 4624, 3, 368, 184, 0, 4608, 4609, 5, 483,
		0, 0, 4609, 4610, 5, 1124, 0, 0, 4610, 4611, 5, 1148, 0, 0, 4611, 4612,
		5, 1135, 0, 0, 4612, 4613, 5, 484, 0, 0, 4613, 4614, 5, 1124, 0, 0, 4614,
		4624, 3, 590, 295, 0, 4615, 4616, 5, 575, 0, 0, 4616, 4617, 5, 1124, 0,
		0, 4617, 4618, 5, 1148, 0, 0, 4618, 4619, 5, 1135, 0, 0, 4619, 4620, 5,
		576, 0, 0, 4620, 4621, 5, 1124, 0, 0, 4621, 4624, 3, 590, 295, 0, 4622,
		4624, 5, 623, 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, 665, 0, 0, 4626, 4627, 5, 1124, 0, 0, 4627, 4638, 5, 1148, 0,
		0, 4628, 4629, 5, 551, 0, 0, 4629, 4630, 5, 1124, 0, 0, 4630, 4638, 5,
		1148, 0, 0, 4631, 4632, 5, 391, 0, 0, 4632, 4633, 5, 1124, 0, 0, 4633,
		4638, 5, 1148, 0, 0, 4634, 4635, 5, 555, 0, 0, 4635, 4636, 5, 1124, 0,
		0, 4636, 4638, 5, 1148, 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, 1135, 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, 1148, 0, 0, 4648, 4639, 1, 0, 0, 0, 4648, 4647,
		1, 0, 0, 0, 4649, 369, 1, 0, 0, 0, 4650, 4651, 5, 681, 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, 681, 0, 0, 4657, 4658, 5, 407, 0, 0, 4658, 4664, 3, 578, 289,
		0, 4659, 4662, 5, 643, 0, 0, 4660, 4661, 5, 65, 0, 0, 4661, 4663, 5, 509,
		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, 681, 0, 0, 4667, 4668, 5, 560, 0, 0, 4668, 4669, 3,
		578, 289, 0, 4669, 375, 1, 0, 0, 0, 4670, 4671, 5, 681, 0, 0, 4671, 4672,
		5, 369, 0, 0, 4672, 4675, 3, 578, 289, 0, 4673, 4674, 5, 536, 0, 0, 4674,
		4676, 5, 553, 0, 0, 4675, 4673, 1, 0, 0, 0, 4675, 4676, 1, 0, 0, 0, 4676,
		377, 1, 0, 0, 0, 4677, 4678, 5, 681, 0, 0, 4678, 4679, 5, 597, 0, 0, 4679,
		4680, 3, 578, 289, 0, 4680, 379, 1, 0, 0, 0, 4681, 4682, 5, 681, 0, 0,
		4682, 4685, 5, 570, 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, 560, 0, 0, 4688, 4689, 3, 584, 292, 0, 4689, 4692,
		5, 68, 0, 0, 4690, 4693, 5, 1148, 0, 0, 4691, 4693, 5, 1159, 0, 0, 4692,
		4690, 1, 0, 0, 0, 4692, 4691, 1, 0, 0, 0, 4693, 383, 1, 0, 0, 0, 4694,
		4695, 5, 708, 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, 560,
		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, 1144, 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, 344, 0, 0, 4714, 4715,
		3, 410, 205, 0, 4715, 4716, 5, 1136, 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, 1136, 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, 1136, 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, 1136, 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, 407, 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, 407, 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,
		407, 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, 1144, 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, 407, 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,
		1144, 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, 663, 0, 0, 4836, 4837, 3, 688, 344, 0, 4837, 4838, 5, 407, 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, 1144, 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, 399, 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, 407, 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, 361, 0, 0, 4864, 4879, 3, 584, 292, 0, 4865, 4870, 5,
		64, 0, 0, 4866, 4868, 5, 520, 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, 539, 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, 669, 0, 0, 4894, 4893, 1, 0, 0,
		0, 4894, 4895, 1, 0, 0, 0, 4895, 4896, 1, 0, 0, 0, 4896, 4898, 5, 1148,
		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, 442, 0, 0, 4908, 4909, 5, 65, 0, 0, 4909, 4914, 3, 418, 209, 0,
		4910, 4911, 5, 1135, 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, 669, 0, 0, 4922, 4921, 1, 0, 0, 0, 4922, 4923,
		1, 0, 0, 0, 4923, 4924, 1, 0, 0, 0, 4924, 4931, 5, 1148, 0, 0, 4925, 4931,
		3, 584, 292, 0, 4926, 4931, 5, 163, 0, 0, 4927, 4928, 5, 114, 0, 0, 4928,
		4931, 5, 435, 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, 1136, 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, 665, 0, 0, 4959, 4964, 3, 446, 223, 0, 4960,
		4961, 5, 1135, 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, 665, 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, 1135, 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, 529, 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, 368, 0, 0, 5012, 5016, 5, 1148, 0, 0, 5013, 5014, 5,
		14, 0, 0, 5014, 5016, 5, 1148, 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, 665, 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, 596, 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,
		665, 0, 0, 5034, 5039, 3, 448, 224, 0, 5035, 5036, 5, 1135, 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, 665, 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, 1135, 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, 596,
		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, 529, 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, 368,
		0, 0, 5092, 5096, 5, 1148, 0, 0, 5093, 5094, 5, 14, 0, 0, 5094, 5096, 5,
		1148, 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, 665, 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, 1135, 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, 1135, 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, 1135, 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, 529, 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, 596, 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, 1135, 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, 1135, 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, 697, 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, 529, 0, 0, 5209, 5219, 5,
		6, 0, 0, 5210, 5211, 5, 59, 0, 0, 5211, 5216, 3, 564, 282, 0, 5212, 5213,
		5, 1135, 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, 1135, 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, 566, 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, 1135, 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, 665, 0, 0, 5251,
		5256, 3, 468, 234, 0, 5252, 5253, 5, 1135, 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, 5260, 5, 147, 0, 0, 5260, 5265, 3, 462, 231, 0, 5261, 5262, 5,
		1135, 0, 0, 5262, 5264, 3, 462, 231, 0, 5263, 5261, 1, 0, 0, 0, 5264, 5267,
		1, 0, 0, 0, 5265, 5263, 1, 0, 0, 0, 5265, 5266, 1, 0, 0, 0, 5266, 5268,
		1, 0, 0, 0, 5267, 5265, 1, 0, 0, 0, 5268, 5270, 5, 118, 0, 0, 5269, 5271,
		7, 66, 0, 0, 5270, 5269, 1, 0, 0, 0, 5270, 5271, 1, 0, 0, 0, 5271, 5272,
		1, 0, 0, 0, 5272, 5273, 3, 466, 233, 0, 5273, 5274, 5, 68, 0, 0, 5274,
		5279, 3, 564, 282, 0, 5275, 5276, 5, 1135, 0, 0, 5276, 5278, 3, 564, 282,
		0, 5277, 5275, 1, 0, 0, 0, 5278, 5281, 1, 0, 0, 0, 5279, 5277, 1, 0, 0,
		0, 5279, 5280, 1, 0, 0, 0, 5280, 5330, 1, 0, 0, 0, 5281, 5279, 1, 0, 0,
		0, 5282, 5283, 5, 147, 0, 0, 5283, 5285, 5, 6, 0, 0, 5284, 5286, 5, 725,
		0, 0, 5285, 5284, 1, 0, 0, 0, 5285, 5286, 1, 0, 0, 0, 5286, 5287, 1, 0,
		0, 0, 5287, 5288, 5, 1135, 0, 0, 5288, 5289, 5, 72, 0, 0, 5289, 5290, 5,
		120, 0, 0, 5290, 5291, 5, 68, 0, 0, 5291, 5296, 3, 564, 282, 0, 5292, 5293,
		5, 1135, 0, 0, 5293, 5295, 3, 564, 282, 0, 5294, 5292, 1, 0, 0, 0, 5295,
		5298, 1, 0, 0, 0, 5296, 5294, 1, 0, 0, 0, 5296, 5297, 1, 0, 0, 0, 5297,
		5330, 1, 0, 0, 0, 5298, 5296, 1, 0, 0, 0, 5299, 5302, 5, 147, 0, 0, 5300,
		5303, 3, 564, 282, 0, 5301, 5303, 3, 584, 292, 0, 5302, 5300, 1, 0, 0,
		0, 5302, 5301, 1, 0, 0, 0, 5303, 5311, 1, 0, 0, 0, 5304, 5307, 5, 1135,
		0, 0, 5305, 5308, 3, 564, 282, 0, 5306, 5308, 3, 584, 292, 0, 5307, 5305,
		1, 0, 0, 0, 5307, 5306, 1, 0, 0, 0, 5308, 5310, 1, 0, 0, 0, 5309, 5304,
		1, 0, 0, 0, 5310, 5313, 1, 0, 0, 0, 5311, 5309, 1, 0, 0, 0, 5311, 5312,
		1, 0, 0, 0, 5312, 5314, 1, 0, 0, 0, 5313, 5311, 1, 0, 0, 0, 5314, 5317,
		5, 68, 0, 0, 5315, 5318, 3, 564, 282, 0, 5316, 5318, 3, 584, 292, 0, 5317,
		5315, 1, 0, 0, 0, 5317, 5316, 1, 0, 0, 0, 5318, 5326, 1, 0, 0, 0, 5319,
		5322, 5, 1135, 0, 0, 5320, 5323, 3, 564, 282, 0, 5321, 5323, 3, 584, 292,
		0, 5322, 5320, 1, 0, 0, 0, 5322, 5321, 1, 0, 0, 0, 5323, 5325, 1, 0, 0,
		0, 5324, 5319, 1, 0, 0, 0, 5325, 5328, 1, 0, 0, 0, 5326, 5324, 1, 0, 0,
		0, 5326, 5327, 1, 0, 0, 0, 5327, 5330, 1, 0, 0, 0, 5328, 5326, 1, 0, 0,
		0, 5329, 5259, 1, 0, 0, 0, 5329, 5282, 1, 0, 0, 0, 5329, 5299, 1, 0, 0,
		0, 5330, 441, 1, 0, 0, 0, 5331, 5332, 5, 147, 0, 0, 5332, 5333, 5, 566,
		0, 0, 5333, 5334, 5, 118, 0, 0, 5334, 5335, 3, 564, 282, 0, 5335, 5336,
		5, 68, 0, 0, 5336, 5341, 3, 564, 282, 0, 5337, 5338, 5, 1135, 0, 0, 5338,
		5340, 3, 564, 282, 0, 5339, 5337, 1, 0, 0, 0, 5340, 5343, 1, 0, 0, 0, 5341,
		5339, 1, 0, 0, 0, 5341, 5342, 1, 0, 0, 0, 5342, 443, 1, 0, 0, 0, 5343,
		5341, 1, 0, 0, 0, 5344, 5345, 5, 153, 0, 0, 5345, 5348, 5, 551, 0, 0, 5346,
		5347, 5, 65, 0, 0, 5347, 5349, 3, 564, 282, 0, 5348, 5346, 1, 0, 0, 0,
		5348, 5349, 1, 0, 0, 0, 5349, 5350, 1, 0, 0, 0, 5350, 5353, 5, 1124, 0,
		0, 5351, 5354, 3, 682, 341, 0, 5352, 5354, 5, 1148, 0, 0, 5353, 5351, 1,
		0, 0, 0, 5353, 5352, 1, 0, 0, 0, 5354, 445, 1, 0, 0, 0, 5355, 5356, 3,
		564, 282, 0, 5356, 5357, 3, 458, 229, 0, 5357, 447, 1, 0, 0, 0, 5358, 5359,
		3, 564, 282, 0, 5359, 5360, 5, 448, 0, 0, 5360, 5361, 5, 19, 0, 0, 5361,
		5362, 5, 551, 0, 0, 5362, 5363, 5, 1148, 0, 0, 5363, 5384, 1, 0, 0, 0,
		5364, 5365, 3, 564, 282, 0, 5365, 5366, 5, 448, 0, 0, 5366, 5367, 5, 19,
		0, 0, 5367, 5368, 5, 991, 0, 0, 5368, 5369, 5, 551, 0, 0, 5369, 5370, 3,
		450, 225, 0, 5370, 5384, 1, 0, 0, 0, 5371, 5372, 3, 564, 282, 0, 5372,
		5373, 5, 448, 0, 0, 5373, 5374, 5, 19, 0, 0, 5374, 5375, 5, 1148, 0, 0,
		5375, 5376, 3, 450, 225, 0, 5376, 5384, 1, 0, 0, 0, 5377, 5378, 3, 564,
		282, 0, 5378, 5379, 5, 448, 0, 0, 5379, 5380, 5, 192, 0, 0, 5380, 5381,
		3, 452, 226, 0, 5381, 5384, 1, 0, 0, 0, 5382, 5384, 3, 564, 282, 0, 5383,
		5358, 1, 0, 0, 0, 5383, 5364, 1, 0, 0, 0, 5383, 5371, 1, 0, 0, 0, 5383,
		5377, 1, 0, 0, 0, 5383, 5382, 1, 0, 0, 0, 5384, 449, 1, 0, 0, 0, 5385,
		5386, 5, 141, 0, 0, 5386, 5388, 5, 1148, 0, 0, 5387, 5385, 1, 0, 0, 0,
		5387, 5388, 1, 0, 0, 0, 5388, 5392, 1, 0, 0, 0, 5389, 5390, 5, 145, 0,
		0, 5390, 5391, 5, 35, 0, 0, 5391, 5393, 5, 551, 0, 0, 5392, 5389, 1, 0,
		0, 0, 5392, 5393, 1, 0, 0, 0, 5393, 451, 1, 0, 0, 0, 5394, 5402, 3, 582,
		291, 0, 5395, 5399, 7, 67, 0, 0, 5396, 5400, 5, 1148, 0, 0, 5397, 5398,
		5, 991, 0, 0, 5398, 5400, 5, 551, 0, 0, 5399, 5396, 1, 0, 0, 0, 5399, 5397,
		1, 0, 0, 0, 5400, 5401, 1, 0, 0, 0, 5401, 5403, 3, 450, 225, 0, 5402, 5395,
		1, 0, 0, 0, 5402, 5403, 1, 0, 0, 0, 5403, 5409, 1, 0, 0, 0, 5404, 5405,
		3, 582, 291, 0, 5405, 5406, 5, 187, 0, 0, 5406, 5407, 3, 682, 341, 0, 5407,
		5409, 1, 0, 0, 0, 5408, 5394, 1, 0, 0, 0, 5408, 5404, 1, 0, 0, 0, 5409,
		453, 1, 0, 0, 0, 5410, 5419, 5, 167, 0, 0, 5411, 5419, 5, 680, 0, 0, 5412,
		5413, 5, 358, 0, 0, 5413, 5419, 5, 1148, 0, 0, 5414, 5415, 5, 465, 0, 0,
		5415, 5419, 5, 1148, 0, 0, 5416, 5417, 5, 640, 0, 0, 5417, 5419, 5, 1148,
		0, 0, 5418, 5410, 1, 0, 0, 0, 5418, 5411, 1, 0, 0, 0, 5418, 5412, 1, 0,
		0, 0, 5418, 5414, 1, 0, 0, 0, 5418, 5416, 1, 0, 0, 0, 5419, 455, 1, 0,
		0, 0, 5420, 5421, 5, 499, 0, 0, 5421, 5429, 3, 590, 295, 0, 5422, 5423,
		5, 502, 0, 0, 5423, 5429, 3, 590, 295, 0, 5424, 5425, 5, 498, 0, 0, 5425,
		5429, 3, 590, 295, 0, 5426, 5427, 5, 503, 0, 0, 5427, 5429, 3, 590, 295,
		0, 5428, 5420, 1, 0, 0, 0, 5428, 5422, 1, 0, 0, 0, 5428, 5424, 1, 0, 0,
		0, 5428, 5426, 1, 0, 0, 0, 5429, 457, 1, 0, 0, 0, 5430, 5431, 5, 551, 0,
		0, 5431, 5438, 5, 420, 0, 0, 5432, 5439, 5, 42, 0, 0, 5433, 5439, 5, 519,
		0, 0, 5434, 5435, 5, 86, 0, 0, 5435, 5436, 3, 590, 295, 0, 5436, 5437,
		5, 691, 0, 0, 5437, 5439, 1, 0, 0, 0, 5438, 5432, 1, 0, 0, 0, 5438, 5433,
		1, 0, 0, 0, 5438, 5434, 1, 0, 0, 0, 5438, 5439, 1, 0, 0, 0, 5439, 5469,
		1, 0, 0, 0, 5440, 5441, 5, 551, 0, 0, 5441, 5444, 5, 445, 0, 0, 5442, 5445,
		5, 42, 0, 0, 5443, 5445, 3, 590, 295, 0, 5444, 5442, 1, 0, 0, 0, 5444,
		5443, 1, 0, 0, 0, 5445, 5469, 1, 0, 0, 0, 5446, 5447, 5, 551, 0, 0, 5447,
		5448, 5, 595, 0, 0, 5448, 5453, 5, 86, 0, 0, 5449, 5454, 5, 42, 0, 0, 5450,
		5451, 3, 590, 295, 0, 5451, 5452, 5, 691, 0, 0, 5452, 5454, 1, 0, 0, 0,
		5453, 5449, 1, 0, 0, 0, 5453, 5450, 1, 0, 0, 0, 5454, 5469, 1, 0, 0, 0,
		5455, 5456, 5, 551, 0, 0, 5456, 5457, 5, 142, 0, 0, 5457, 5459, 5, 35,
		0, 0, 5458, 5460, 7, 68, 0, 0, 5459, 5458, 1, 0, 0, 0, 5459, 5460, 1, 0,
		0, 0, 5460, 5469, 1, 0, 0, 0, 5461, 5462, 5, 424, 0, 0, 5462, 5469, 3,
		590, 295, 0, 5463, 5466, 5, 552, 0, 0, 5464, 5467, 3, 590, 295, 0, 5465,
		5467, 5, 657, 0, 0, 5466, 5464, 1, 0, 0, 0, 5466, 5465, 1, 0, 0, 0, 5467,
		5469, 1, 0, 0, 0, 5468, 5430, 1, 0, 0, 0, 5468, 5440, 1, 0, 0, 0, 5468,
		5446, 1, 0, 0, 0, 5468, 5455, 1, 0, 0, 0, 5468, 5461, 1, 0, 0, 0, 5468,
		5463, 1, 0, 0, 0, 5469, 459, 1, 0, 0, 0, 5470, 5471, 5, 332, 0, 0, 5471,
		5472, 7, 69, 0, 0, 5472, 461, 1, 0, 0, 0, 5473, 5478, 3, 464, 232, 0, 5474,
		5475, 5, 1133, 0, 0, 5475, 5476, 3, 616, 308, 0, 5476, 5477, 5, 1134, 0,
		0, 5477, 5479, 1, 0, 0, 0, 5478, 5474, 1, 0, 0, 0, 5478, 5479, 1, 0, 0,
		0, 5479, 463, 1, 0, 0, 0, 5480, 5482, 5, 6, 0, 0, 5481, 5483, 5, 725, 0,
		0, 5482, 5481, 1, 0, 0, 0, 5482, 5483, 1, 0, 0, 0, 5483, 5574, 1, 0, 0,
		0, 5484, 5486, 5, 7, 0, 0, 5485, 5487, 5, 733, 0, 0, 5486, 5485, 1, 0,
		0, 0, 5486, 5487, 1, 0, 0, 0, 5487, 5574, 1, 0, 0, 0, 5488, 5496, 5, 33,
		0, 0, 5489, 5490, 5, 649, 0, 0, 5490, 5497, 5, 742, 0, 0, 5491, 5497, 5,
		733, 0, 0, 5492, 5497, 5, 671, 0, 0, 5493, 5497, 5, 665, 0, 0, 5494, 5497,
		5, 647, 0, 0, 5495, 5497, 5, 596, 0, 0, 5496, 5489, 1, 0, 0, 0, 5496, 5491,
		1, 0, 0, 0, 5496, 5492, 1, 0, 0, 0, 5496, 5493, 1, 0, 0, 0, 5496, 5494,
		1, 0, 0, 0, 5496, 5495, 1, 0, 0, 0, 5496, 5497, 1, 0, 0, 0, 5497, 5574,
		1, 0, 0, 0, 5498, 5574, 5, 44, 0, 0, 5499, 5501, 5, 51, 0, 0, 5500, 5502,
		5, 596, 0, 0, 5501, 5500, 1, 0, 0, 0, 5501, 5502, 1, 0, 0, 0, 5502, 5574,
		1, 0, 0, 0, 5503, 5574, 5, 415, 0, 0, 5504, 5574, 5, 708, 0, 0, 5505, 5574,
		5, 709, 0, 0, 5506, 5507, 5, 72, 0, 0, 5507, 5574, 5, 120, 0, 0, 5508,
		5574, 5, 81, 0, 0, 5509, 5574, 5, 85, 0, 0, 5510, 5511, 5, 103, 0, 0, 5511,
		5574, 5, 742, 0, 0, 5512, 5574, 5, 726, 0, 0, 5513, 5574, 5, 566, 0, 0,
		5514, 5574, 5, 136, 0, 0, 5515, 5574, 5, 727, 0, 0, 5516, 5517, 5, 588,
		0, 0, 5517, 5574, 7, 70, 0, 0, 5518, 5574, 5, 152, 0, 0, 5519, 5520, 5,
		155, 0, 0, 5520, 5574, 7, 71, 0, 0, 5521, 5574, 5, 739, 0, 0, 5522, 5574,
		5, 740, 0, 0, 5523, 5574, 5, 177, 0, 0, 5524, 5574, 5, 184, 0, 0, 5525,
		5574, 5, 185, 0, 0, 5526, 5574, 5, 698, 0, 0, 5527, 5574, 5, 699, 0, 0,
		5528, 5574, 5, 700, 0, 0, 5529, 5574, 5, 701, 0, 0, 5530, 5574, 5, 702,
		0, 0, 5531, 5574, 5, 703, 0, 0, 5532, 5574, 5, 704, 0, 0, 5533, 5574, 5,
		705, 0, 0, 5534, 5574, 5, 706, 0, 0, 5535, 5574, 5, 707, 0, 0, 5536, 5574,
		5, 710, 0, 0, 5537, 5574, 5, 711, 0, 0, 5538, 5574, 5, 712, 0, 0, 5539,
		5574, 5, 713, 0, 0, 5540, 5574, 5, 714, 0, 0, 5541, 5574, 5, 715, 0, 0,
		5542, 5574, 5, 716, 0, 0, 5543, 5574, 5, 717, 0, 0, 5544, 5574, 5, 718,
		0, 0, 5545, 5574, 5, 719, 0, 0, 5546, 5574, 5, 722, 0, 0, 5547, 5574, 5,
		723, 0, 0, 5548, 5574, 5, 724, 0, 0, 5549, 5574, 5, 728, 0, 0, 5550, 5574,
		5, 729, 0, 0, 5551, 5574, 5, 730, 0, 0, 5552, 5574, 5, 731, 0, 0, 5553,
		5574, 5, 732, 0, 0, 5554, 5574, 5, 735, 0, 0, 5555, 5574, 5, 736, 0, 0,
		5556, 5574, 5, 737, 0, 0, 5557, 5574, 5, 158, 0, 0, 5558, 5574, 5, 738,
		0, 0, 5559, 5574, 5, 1077, 0, 0, 5560, 5574, 5, 741, 0, 0, 5561, 5574,
		5, 743, 0, 0, 5562, 5574, 5, 1088, 0, 0, 5563, 5574, 5, 744, 0, 0, 5564,
		5574, 5, 745, 0, 0, 5565, 5566, 5, 102, 0, 0, 5566, 5567, 5, 68, 0, 0,
		5567, 5574, 5, 734, 0, 0, 5568, 5569, 5, 152, 0, 0, 5569, 5570, 5, 87,
		0, 0, 5570, 5574, 5, 734, 0, 0, 5571, 5572, 5, 720, 0, 0, 5572, 5574, 5,
		721, 0, 0, 5573, 5480, 1, 0, 0, 0, 5573, 5484, 1, 0, 0, 0, 5573, 5488,
		1, 0, 0, 0, 5573, 5498, 1, 0, 0, 0, 5573, 5499, 1, 0, 0, 0, 5573, 5503,
		1, 0, 0, 0, 5573, 5504, 1, 0, 0, 0, 5573, 5505, 1, 0, 0, 0, 5573, 5506,
		1, 0, 0, 0, 5573, 5508, 1, 0, 0, 0, 5573, 5509, 1, 0, 0, 0, 5573, 5510,
		1, 0, 0, 0, 5573, 5512, 1, 0, 0, 0, 5573, 5513, 1, 0, 0, 0, 5573, 5514,
		1, 0, 0, 0, 5573, 5515, 1, 0, 0, 0, 5573, 5516, 1, 0, 0, 0, 5573, 5518,
		1, 0, 0, 0, 5573, 5519, 1, 0, 0, 0, 5573, 5521, 1, 0, 0, 0, 5573, 5522,
		1, 0, 0, 0, 5573, 5523, 1, 0, 0, 0, 5573, 5524, 1, 0, 0, 0, 5573, 5525,
		1, 0, 0, 0, 5573, 5526, 1, 0, 0, 0, 5573, 5527, 1, 0, 0, 0, 5573, 5528,
		1, 0, 0, 0, 5573, 5529, 1, 0, 0, 0, 5573, 5530, 1, 0, 0, 0, 5573, 5531,
		1, 0, 0, 0, 5573, 5532, 1, 0, 0, 0, 5573, 5533, 1, 0, 0, 0, 5573, 5534,
		1, 0, 0, 0, 5573, 5535, 1, 0, 0, 0, 5573, 5536, 1, 0, 0, 0, 5573, 5537,
		1, 0, 0, 0, 5573, 5538, 1, 0, 0, 0, 5573, 5539, 1, 0, 0, 0, 5573, 5540,
		1, 0, 0, 0, 5573, 5541, 1, 0, 0, 0, 5573, 5542, 1, 0, 0, 0, 5573, 5543,
		1, 0, 0, 0, 5573, 5544, 1, 0, 0, 0, 5573, 5545, 1, 0, 0, 0, 5573, 5546,
		1, 0, 0, 0, 5573, 5547, 1, 0, 0, 0, 5573, 5548, 1, 0, 0, 0, 5573, 5549,
		1, 0, 0, 0, 5573, 5550, 1, 0, 0, 0, 5573, 5551, 1, 0, 0, 0, 5573, 5552,
		1, 0, 0, 0, 5573, 5553, 1, 0, 0, 0, 5573, 5554, 1, 0, 0, 0, 5573, 5555,
		1, 0, 0, 0, 5573, 5556, 1, 0, 0, 0, 5573, 5557, 1, 0, 0, 0, 5573, 5558,
		1, 0, 0, 0, 5573, 5559, 1, 0, 0, 0, 5573, 5560, 1, 0, 0, 0, 5573, 5561,
		1, 0, 0, 0, 5573, 5562, 1, 0, 0, 0, 5573, 5563, 1, 0, 0, 0, 5573, 5564,
		1, 0, 0, 0, 5573, 5565, 1, 0, 0, 0, 5573, 5568, 1, 0, 0, 0, 5573, 5571,
		1, 0, 0, 0, 5574, 465, 1, 0, 0, 0, 5575, 5592, 5, 1117, 0, 0, 5576, 5577,
		5, 1117, 0, 0, 5577, 5578, 5, 1132, 0, 0, 5578, 5592, 5, 1117, 0, 0, 5579,
		5580, 3, 584, 292, 0, 5580, 5581, 5, 1132, 0, 0, 5581, 5582, 5, 1117, 0,
		0, 5582, 5592, 1, 0, 0, 0, 5583, 5584, 3, 584, 292, 0, 5584, 5585, 5, 1132,
		0, 0, 5585, 5586, 3, 584, 292, 0, 5586, 5592, 1, 0, 0, 0, 5587, 5588, 3,
		584, 292, 0, 5588, 5589, 3, 588, 294, 0, 5589, 5592, 1, 0, 0, 0, 5590,
		5592, 3, 584, 292, 0, 5591, 5575, 1, 0, 0, 0, 5591, 5576, 1, 0, 0, 0, 5591,
		5579, 1, 0, 0, 0, 5591, 5583, 1, 0, 0, 0, 5591, 5587, 1, 0, 0, 0, 5591,
		5590, 1, 0, 0, 0, 5592, 467, 1, 0, 0, 0, 5593, 5594, 3, 564, 282, 0, 5594,
		5595, 5, 175, 0, 0, 5595, 5596, 3, 564, 282, 0, 5596, 469, 1, 0, 0, 0,
		5597, 5599, 5, 9, 0, 0, 5598, 5600, 7, 72, 0, 0, 5599, 5598, 1, 0, 0, 0,
		5599, 5600, 1, 0, 0, 0, 5600, 5601, 1, 0, 0, 0, 5601, 5602, 7, 54, 0, 0,
		5602, 5620, 3, 620, 310, 0, 5603, 5604, 5, 184, 0, 0, 5604, 5605, 5, 76,
		0, 0, 5605, 5606, 5, 118, 0, 0, 5606, 5611, 3, 556, 278, 0, 5607, 5608,
		5, 1135, 0, 0, 5608, 5610, 3, 556, 278, 0, 5609, 5607, 1, 0, 0, 0, 5610,
		5613, 1, 0, 0, 0, 5611, 5609, 1, 0, 0, 0, 5611, 5612, 1, 0, 0, 0, 5612,
		5618, 1, 0, 0, 0, 5613, 5611, 1, 0, 0, 0, 5614, 5615, 5, 192, 0, 0, 5615,
		5616, 3, 590, 295, 0, 5616, 5617, 5, 18, 0, 0, 5617, 5619, 1, 0, 0, 0,
		5618, 5614, 1, 0, 0, 0, 5618, 5619, 1, 0, 0, 0, 5619, 5621, 1, 0, 0, 0,
		5620, 5603, 1, 0, 0, 0, 5620, 5621, 1, 0, 0, 0, 5621, 5633, 1, 0, 0, 0,
		5622, 5623, 5, 51, 0, 0, 5623, 5624, 5, 76, 0, 0, 5624, 5625, 5, 118, 0,
		0, 5625, 5630, 3, 556, 278, 0, 5626, 5627, 5, 1135, 0, 0, 5627, 5629, 3,
		556, 278, 0, 5628, 5626, 1, 0, 0, 0, 5629, 5632, 1, 0, 0, 0, 5630, 5628,
		1, 0, 0, 0, 5630, 5631, 1, 0, 0, 0, 5631, 5634, 1, 0, 0, 0, 5632, 5630,
		1, 0, 0, 0, 5633, 5622, 1, 0, 0, 0, 5633, 5634, 1, 0, 0, 0, 5634, 471,
		1, 0, 0, 0, 5635, 5636, 5, 26, 0, 0, 5636, 5637, 5, 172, 0, 0, 5637, 5641,
		3, 620, 310, 0, 5638, 5640, 3, 480, 240, 0, 5639, 5638, 1, 0, 0, 0, 5640,
		5643, 1, 0, 0, 0, 5641, 5639, 1, 0, 0, 0, 5641, 5642, 1, 0, 0, 0, 5642,
		473, 1, 0, 0, 0, 5643, 5641, 1, 0, 0, 0, 5644, 5645, 5, 356, 0, 0, 5645,
		5646, 5, 172, 0, 0, 5646, 5648, 3, 620, 310, 0, 5647, 5649, 7, 73, 0, 0,
		5648, 5647, 1, 0, 0, 0, 5648, 5649, 1, 0, 0, 0, 5649, 475, 1, 0, 0, 0,
		5650, 5652, 5, 119, 0, 0, 5651, 5653, 7, 72, 0, 0, 5652, 5651, 1, 0, 0,
		0, 5652, 5653, 1, 0, 0, 0, 5653, 5654, 1, 0, 0, 0, 5654, 5655, 7, 54, 0,
		0, 5655, 5656, 3, 620, 310, 0, 5656, 477, 1, 0, 0, 0, 5657, 5659, 5, 580,
		0, 0, 5658, 5660, 7, 72, 0, 0, 5659, 5658, 1, 0, 0, 0, 5659, 5660, 1, 0,
		0, 0, 5660, 5661, 1, 0, 0, 0, 5661, 5662, 5, 172, 0, 0, 5662, 5664, 3,
		620, 310, 0, 5663, 5665, 5, 568, 0, 0, 5664, 5663, 1, 0, 0, 0, 5664, 5665,
		1, 0, 0, 0, 5665, 5667, 1, 0, 0, 0, 5666, 5668, 5, 422, 0, 0, 5667, 5666,
		1, 0, 0, 0, 5667, 5668, 1, 0, 0, 0, 5668, 5670, 1, 0, 0, 0, 5669, 5671,
		5, 666, 0, 0, 5670, 5669, 1, 0, 0, 0, 5670, 5671, 1, 0, 0, 0, 5671, 479,
		1, 0, 0, 0, 5672, 5673, 5, 65, 0, 0, 5673, 5680, 5, 664, 0, 0, 5674, 5680,
		5, 568, 0, 0, 5675, 5680, 5, 425, 0, 0, 5676, 5680, 5, 504, 0, 0, 5677,
		5680, 5, 422, 0, 0, 5678, 5680, 5, 354, 0, 0, 5679, 5672, 1, 0, 0, 0, 5679,
		5674, 1, 0, 0, 0, 5679, 5675, 1, 0, 0, 0, 5679, 5676, 1, 0, 0, 0, 5679,
		5677, 1, 0, 0, 0, 5679, 5678, 1, 0, 0, 0, 5680, 481, 1, 0, 0, 0, 5681,
		5683, 5, 33, 0, 0, 5682, 5684, 5, 335, 0, 0, 5683, 5682, 1, 0, 0, 0, 5683,
		5684, 1, 0, 0, 0, 5684, 5685, 1, 0, 0, 0, 5685, 5687, 5, 437, 0, 0, 5686,
		5688, 3, 642, 321, 0, 5687, 5686, 1, 0, 0, 0, 5687, 5688, 1, 0, 0, 0, 5688,
		5689, 1, 0, 0, 0, 5689, 5690, 3, 584, 292, 0, 5690, 5691, 5, 594, 0, 0,
		5691, 5692, 7, 74, 0, 0, 5692, 5693, 5, 619, 0, 0, 5693, 5694, 5, 1148,
		0, 0, 5694, 483, 1, 0, 0, 0, 5695, 5696, 5, 456, 0, 0, 5696, 5697, 5, 554,
		0, 0, 5697, 5698, 3, 584, 292, 0, 5698, 5699, 5, 619, 0, 0, 5699, 5700,
		5, 1148, 0, 0, 5700, 485, 1, 0, 0, 0, 5701, 5702, 5, 661, 0, 0, 5702, 5703,
		5, 554, 0, 0, 5703, 5704, 3, 584, 292, 0, 5704, 487, 1, 0, 0, 0, 5705,
		5706, 5, 153, 0, 0, 5706, 5707, 3, 492, 246, 0, 5707, 5710, 7, 75, 0, 0,
		5708, 5711, 3, 688, 344, 0, 5709, 5711, 5, 118, 0, 0, 5710, 5708, 1, 0,
		0, 0, 5710, 5709, 1, 0, 0, 0, 5711, 5721, 1, 0, 0, 0, 5712, 5713, 5, 1135,
		0, 0, 5713, 5714, 3, 492, 246, 0, 5714, 5717, 7, 75, 0, 0, 5715, 5718,
		3, 688, 344, 0, 5716, 5718, 5, 118, 0, 0, 5717, 5715, 1, 0, 0, 0, 5717,
		5716, 1, 0, 0, 0, 5718, 5720, 1, 0, 0, 0, 5719, 5712, 1, 0, 0, 0, 5720,
		5723, 1, 0, 0, 0, 5721, 5719, 1, 0, 0, 0, 5721, 5722, 1, 0, 0, 0, 5722,
		5758, 1, 0, 0, 0, 5723, 5721, 1, 0, 0, 0, 5724, 5725, 5, 153, 0, 0, 5725,
		5728, 3, 60, 30, 0, 5726, 5729, 3, 568, 284, 0, 5727, 5729, 5, 42, 0, 0,
		5728, 5726, 1, 0, 0, 0, 5728, 5727, 1, 0, 0, 0, 5729, 5758, 1, 0, 0, 0,
		5730, 5731, 5, 153, 0, 0, 5731, 5738, 5, 517, 0, 0, 5732, 5735, 3, 568,
		284, 0, 5733, 5734, 5, 27, 0, 0, 5734, 5736, 3, 570, 285, 0, 5735, 5733,
		1, 0, 0, 0, 5735, 5736, 1, 0, 0, 0, 5736, 5739, 1, 0, 0, 0, 5737, 5739,
		5, 42, 0, 0, 5738, 5732, 1, 0, 0, 0, 5738, 5737, 1, 0, 0, 0, 5739, 5758,
		1, 0, 0, 0, 5740, 5758, 3, 444, 222, 0, 5741, 5758, 3, 318, 159, 0, 5742,
		5758, 3, 316, 158, 0, 5743, 5744, 5, 153, 0, 0, 5744, 5745, 3, 550, 275,
		0, 5745, 5746, 7, 75, 0, 0, 5746, 5754, 3, 688, 344, 0, 5747, 5748, 5,
		1135, 0, 0, 5748, 5749, 3, 550, 275, 0, 5749, 5750, 7, 75, 0, 0, 5750,
		5751, 3, 688, 344, 0, 5751, 5753, 1, 0, 0, 0, 5752, 5747, 1, 0, 0, 0, 5753,
		5756, 1, 0, 0, 0, 5754, 5752, 1, 0, 0, 0, 5754, 5755, 1, 0, 0, 0, 5755,
		5758, 1, 0, 0, 0, 5756, 5754, 1, 0, 0, 0, 5757, 5705, 1, 0, 0, 0, 5757,
		5724, 1, 0, 0, 0, 5757, 5730, 1, 0, 0, 0, 5757, 5740, 1, 0, 0, 0, 5757,
		5741, 1, 0, 0, 0, 5757, 5742, 1, 0, 0, 0, 5757, 5743, 1, 0, 0, 0, 5758,
		489, 1, 0, 0, 0, 5759, 5760, 5, 155, 0, 0, 5760, 5761, 7, 56, 0, 0, 5761,
		5913, 5, 476, 0, 0, 5762, 5763, 5, 155, 0, 0, 5763, 5764, 7, 76, 0, 0,
		5764, 5767, 5, 416, 0, 0, 5765, 5766, 5, 80, 0, 0, 5766, 5768, 5, 1148,
		0, 0, 5767, 5765, 1, 0, 0, 0, 5767, 5768, 1, 0, 0, 0, 5768, 5771, 1, 0,
		0, 0, 5769, 5770, 5, 68, 0, 0, 5770, 5772, 3, 590, 295, 0, 5771, 5769,
		1, 0, 0, 0, 5771, 5772, 1, 0, 0, 0, 5772, 5780, 1, 0, 0, 0, 5773, 5777,
		5, 99, 0, 0, 5774, 5775, 3, 590, 295, 0, 5775, 5776, 5, 1135, 0, 0, 5776,
		5778, 1, 0, 0, 0, 5777, 5774, 1, 0, 0, 0, 5777, 5778, 1, 0, 0, 0, 5778,
		5779, 1, 0, 0, 0, 5779, 5781, 3, 590, 295, 0, 5780, 5773, 1, 0, 0, 0, 5780,
		5781, 1, 0, 0, 0, 5781, 5913, 1, 0, 0, 0, 5782, 5783, 5, 155, 0, 0, 5783,
		5785, 3, 494, 247, 0, 5784, 5786, 3, 496, 248, 0, 5785, 5784, 1, 0, 0,
		0, 5785, 5786, 1, 0, 0, 0, 5786, 5913, 1, 0, 0, 0, 5787, 5789, 5, 155,
		0, 0, 5788, 5790, 5, 436, 0, 0, 5789, 5788, 1, 0, 0, 0, 5789, 5790, 1,
		0, 0, 0, 5790, 5791, 1, 0, 0, 0, 5791, 5792, 7, 41, 0, 0, 5792, 5793, 7,
		77, 0, 0, 5793, 5796, 3, 552, 276, 0, 5794, 5795, 7, 77, 0, 0, 5795, 5797,
		3, 584, 292, 0, 5796, 5794, 1, 0, 0, 0, 5796, 5797, 1, 0, 0, 0, 5797, 5799,
		1, 0, 0, 0, 5798, 5800, 3, 496, 248, 0, 5799, 5798, 1, 0, 0, 0, 5799, 5800,
		1, 0, 0, 0, 5800, 5913, 1, 0, 0, 0, 5801, 5802, 5, 155, 0, 0, 5802, 5803,
		5, 33, 0, 0, 5803, 5805, 7, 0, 0, 0, 5804, 5806, 3, 642, 321, 0, 5805,
		5804, 1, 0, 0, 0, 5805, 5806, 1, 0, 0, 0, 5806, 5807, 1, 0, 0, 0, 5807,
		5913, 3, 584, 292, 0, 5808, 5809, 5, 155, 0, 0, 5809, 5810, 5, 33, 0, 0,
		5810, 5811, 7, 78, 0, 0, 5811, 5913, 3, 550, 275, 0, 5812, 5813, 5, 155,
		0, 0, 5813, 5814, 5, 33, 0, 0, 5814, 5815, 5, 665, 0, 0, 5815, 5913, 3,
		564, 282, 0, 5816, 5817, 5, 155, 0, 0, 5817, 5818, 5, 409, 0, 0, 5818,
		5819, 3, 572, 286, 0, 5819, 5820, 7, 79, 0, 0, 5820, 5913, 1, 0, 0, 0,
		5821, 5822, 5, 155, 0, 0, 5822, 5913, 3, 498, 249, 0, 5823, 5824, 5, 155,
		0, 0, 5824, 5832, 7, 80, 0, 0, 5825, 5829, 5, 99, 0, 0, 5826, 5827, 3,
		590, 295, 0, 5827, 5828, 5, 1135, 0, 0, 5828, 5830, 1, 0, 0, 0, 5829, 5826,
		1, 0, 0, 0, 5829, 5830, 1, 0, 0, 0, 5830, 5831, 1, 0, 0, 0, 5831, 5833,
		3, 590, 295, 0, 5832, 5825, 1, 0, 0, 0, 5832, 5833, 1, 0, 0, 0, 5833, 5913,
		1, 0, 0, 0, 5834, 5835, 5, 155, 0, 0, 5835, 5836, 5, 290, 0, 0, 5836, 5837,
		5, 1133, 0, 0, 5837, 5838, 5, 1117, 0, 0, 5838, 5839, 5, 1134, 0, 0, 5839,
		5913, 7, 80, 0, 0, 5840, 5841, 5, 155, 0, 0, 5841, 5844, 3, 500, 250, 0,
		5842, 5843, 7, 77, 0, 0, 5843, 5845, 3, 584, 292, 0, 5844, 5842, 1, 0,
		0, 0, 5844, 5845, 1, 0, 0, 0, 5845, 5847, 1, 0, 0, 0, 5846, 5848, 3, 496,
		248, 0, 5847, 5846, 1, 0, 0, 0, 5847, 5848, 1, 0, 0, 0, 5848, 5913, 1,
		0, 0, 0, 5849, 5850, 5, 155, 0, 0, 5850, 5851, 7, 81, 0, 0, 5851, 5852,
		5, 364, 0, 0, 5852, 5913, 3, 550, 275, 0, 5853, 5854, 5, 155, 0, 0, 5854,
		5857, 5, 440, 0, 0, 5855, 5856, 5, 65, 0, 0, 5856, 5858, 3, 564, 282, 0,
		5857, 5855, 1, 0, 0, 0, 5857, 5858, 1, 0, 0, 0, 5858, 5913, 1, 0, 0, 0,
		5859, 5860, 5, 155, 0, 0, 5860, 5861, 7, 82, 0, 0, 5861, 5862, 7, 77, 0,
		0, 5862, 5865, 3, 552, 276, 0, 5863, 5864, 7, 77, 0, 0, 5864, 5866, 3,
		584, 292, 0, 5865, 5863, 1, 0, 0, 0, 5865, 5866, 1, 0, 0, 0, 5866, 5869,
		1, 0, 0, 0, 5867, 5868, 5, 190, 0, 0, 5868, 5870, 3, 688, 344, 0, 5869,
		5867, 1, 0, 0, 0, 5869, 5870, 1, 0, 0, 0, 5870, 5913, 1, 0, 0, 0, 5871,
		5872, 5, 155, 0, 0, 5872, 5873, 5, 539, 0, 0, 5873, 5876, 5, 742, 0, 0,
		5874, 5875, 7, 77, 0, 0, 5875, 5877, 3, 584, 292, 0, 5876, 5874, 1, 0,
		0, 0, 5876, 5877, 1, 0, 0, 0, 5877, 5879, 1, 0, 0, 0, 5878, 5880, 3, 496,
		248, 0, 5879, 5878, 1, 0, 0, 0, 5879, 5880, 1, 0, 0, 0, 5880, 5913, 1,
		0, 0, 0, 5881, 5882, 5, 155, 0, 0, 5882, 5883, 5, 564, 0, 0, 5883, 5888,
		3, 502, 251, 0, 5884, 5885, 5, 1135, 0, 0, 5885, 5887, 3, 502, 251, 0,
		5886, 5884, 1, 0, 0, 0, 5887, 5890, 1, 0, 0, 0, 5888, 5886, 1, 0, 0, 0,
		5888, 5889, 1, 0, 0, 0, 5889, 5894, 1, 0, 0, 0, 5890, 5888, 1, 0, 0, 0,
		5891, 5892, 5, 65, 0, 0, 5892, 5893, 5, 567, 0, 0, 5893, 5895, 3, 590,
		295, 0, 5894, 5891, 1, 0, 0, 0, 5894, 5895, 1, 0, 0, 0, 5895, 5896, 1,
		0, 0, 0, 5896, 5900, 5, 99, 0, 0, 5897, 5898, 3, 590, 295, 0, 5898, 5899,
		5, 1135, 0, 0, 5899, 5901, 1, 0, 0, 0, 5900, 5897, 1, 0, 0, 0, 5900, 5901,
		1, 0, 0, 0, 5901, 5902, 1, 0, 0, 0, 5902, 5903, 3, 590, 295, 0, 5903, 5913,
		1, 0, 0, 0, 5904, 5905, 5, 155, 0, 0, 5905, 5906, 5, 614, 0, 0, 5906, 5910,
		5, 634, 0, 0, 5907, 5908, 5, 65, 0, 0, 5908, 5909, 5, 355, 0, 0, 5909,
		5911, 5, 1148, 0, 0, 5910, 5907, 1, 0, 0, 0, 5910, 5911, 1, 0, 0, 0, 5911,
		5913, 1, 0, 0, 0, 5912, 5759, 1, 0, 0, 0, 5912, 5762, 1, 0, 0, 0, 5912,
		5782, 1, 0, 0, 0, 5912, 5787, 1, 0, 0, 0, 5912, 5801, 1, 0, 0, 0, 5912,
		5808, 1, 0, 0, 0, 5912, 5812, 1, 0, 0, 0, 5912, 5816, 1, 0, 0, 0, 5912,
		5821, 1, 0, 0, 0, 5912, 5823, 1, 0, 0, 0, 5912, 5834, 1, 0, 0, 0, 5912,
		5840, 1, 0, 0, 0, 5912, 5849, 1, 0, 0, 0, 5912, 5853, 1, 0, 0, 0, 5912,
		5859, 1, 0, 0, 0, 5912, 5871, 1, 0, 0, 0, 5912, 5881, 1, 0, 0, 0, 5912,
		5904, 1, 0, 0, 0, 5913, 491, 1, 0, 0, 0, 5914, 5925, 5, 1159, 0, 0, 5915,
		5925, 5, 1160, 0, 0, 5916, 5917, 5, 1137, 0, 0, 5917, 5919, 5, 1137, 0,
		0, 5918, 5916, 1, 0, 0, 0, 5918, 5919, 1, 0, 0, 0, 5919, 5920, 1, 0, 0,
		0, 5920, 5922, 7, 83, 0, 0, 5921, 5918, 1, 0, 0, 0, 5921, 5922, 1, 0, 0,
		0, 5922, 5923, 1, 0, 0, 0, 5923, 5925, 3, 584, 292, 0, 5924, 5914, 1, 0,
		0, 0, 5924, 5915, 1, 0, 0, 0, 5924, 5921, 1, 0, 0, 0, 5925, 493, 1, 0,
		0, 0, 5926, 5927, 5, 25, 0, 0, 5927, 5940, 5, 153, 0, 0, 5928, 5940, 5,
		844, 0, 0, 5929, 5940, 5, 40, 0, 0, 5930, 5940, 5, 151, 0, 0, 5931, 5932,
		5, 437, 0, 0, 5932, 5940, 5, 634, 0, 0, 5933, 5934, 5, 131, 0, 0, 5934,
		5940, 5, 634, 0, 0, 5935, 5937, 7, 55, 0, 0, 5936, 5935, 1, 0, 0, 0, 5936,
		5937, 1, 0, 0, 0, 5937, 5938, 1, 0, 0, 0, 5938, 5940, 7, 84, 0, 0, 5939,
		5926, 1, 0, 0, 0, 5939, 5928, 1, 0, 0, 0, 5939, 5929, 1, 0, 0, 0, 5939,
		5930, 1, 0, 0, 0, 5939, 5931, 1, 0, 0, 0, 5939, 5933, 1, 0, 0, 0, 5939,
		5936, 1, 0, 0, 0, 5940, 495, 1, 0, 0, 0, 5941, 5942, 5, 98, 0, 0, 5942,
		5946, 5, 1148, 0, 0, 5943, 5944, 5, 190, 0, 0, 5944, 5946, 3, 688, 344,
		0, 5945, 5941, 1, 0, 0, 0, 5945, 5943, 1, 0, 0, 0, 5946, 497, 1, 0, 0,
		0, 5947, 5949, 5, 636, 0, 0, 5948, 5947, 1, 0, 0, 0, 5948, 5949, 1, 0,
		0, 0, 5949, 5950, 1, 0, 0, 0, 5950, 5965, 5, 410, 0, 0, 5951, 5952, 5,
		477, 0, 0, 5952, 5965, 5, 634, 0, 0, 5953, 5965, 5, 556, 0, 0, 5954, 5965,
		5, 725, 0, 0, 5955, 5957, 5, 436, 0, 0, 5956, 5955, 1, 0, 0, 0, 5956, 5957,
		1, 0, 0, 0, 5957, 5958, 1, 0, 0, 0, 5958, 5965, 5, 563, 0, 0, 5959, 5965,
		5, 565, 0, 0, 5960, 5961, 5, 614, 0, 0, 5961, 5965, 5, 447, 0, 0, 5962,
		5965, 5, 339, 0, 0, 5963, 5965, 5, 383, 0, 0, 5964, 5948, 1, 0, 0, 0, 5964,
		5951, 1, 0, 0, 0, 5964, 5953, 1, 0, 0, 0, 5964, 5954, 1, 0, 0, 0, 5964,
		5956, 1, 0, 0, 0, 5964, 5959, 1, 0, 0, 0, 5964, 5960, 1, 0, 0, 0, 5964,
		5962, 1, 0, 0, 0, 5964, 5963, 1, 0, 0, 0, 5965, 499, 1, 0, 0, 0, 5966,
		5975, 5, 416, 0, 0, 5967, 5968, 5, 172, 0, 0, 5968, 5975, 5, 634, 0, 0,
		5969, 5971, 5, 436, 0, 0, 5970, 5969, 1, 0, 0, 0, 5970, 5971, 1, 0, 0,
		0, 5971, 5972, 1, 0, 0, 0, 5972, 5975, 5, 742, 0, 0, 5973, 5975, 5, 655,
		0, 0, 5974, 5966, 1, 0, 0, 0, 5974, 5967, 1, 0, 0, 0, 5974, 5970, 1, 0,
		0, 0, 5974, 5973, 1, 0, 0, 0, 5975, 501, 1, 0, 0, 0, 5976, 5989, 5, 6,
		0, 0, 5977, 5978, 5, 347, 0, 0, 5978, 5989, 5, 461, 0, 0, 5979, 5980, 5,
		382, 0, 0, 5980, 5989, 5, 645, 0, 0, 5981, 5989, 5, 385, 0, 0, 5982, 5989,
		5, 463, 0, 0, 5983, 5989, 5, 792, 0, 0, 5984, 5985, 5, 544, 0, 0, 5985,
		5989, 5, 426, 0, 0, 5986, 5989, 5, 621, 0, 0, 5987, 5989, 5, 644, 0, 0,
		5988, 5976, 1, 0, 0, 0, 5988, 5977, 1, 0, 0, 0, 5988, 5979, 1, 0, 0, 0,
		5988, 5981, 1, 0, 0, 0, 5988, 5982, 1, 0, 0, 0, 5988, 5983, 1, 0, 0, 0,
		5988, 5984, 1, 0, 0, 0, 5988, 5986, 1, 0, 0, 0, 5988, 5987, 1, 0, 0, 0,
		5989, 503, 1, 0, 0, 0, 5990, 5991, 5, 345, 0, 0, 5991, 5992, 5, 1148, 0,
		0, 5992, 505, 1, 0, 0, 0, 5993, 5994, 5, 351, 0, 0, 5994, 5995, 5, 81,
		0, 0, 5995, 6000, 3, 518, 259, 0, 5996, 5997, 5, 1135, 0, 0, 5997, 5999,
		3, 518, 259, 0, 5998, 5996, 1, 0, 0, 0, 5999, 6002, 1, 0, 0, 0, 6000, 5998,
		1, 0, 0, 0, 6000, 6001, 1, 0, 0, 0, 6001, 6010, 1, 0, 0, 0, 6002, 6000,
		1, 0, 0, 0, 6003, 6004, 5, 129, 0, 0, 6004, 6007, 5, 1133, 0, 0, 6005,
		6008, 3, 616, 308, 0, 6006, 6008, 5, 6, 0, 0, 6007, 6005, 1, 0, 0, 0, 6007,
		6006, 1, 0, 0, 0, 6008, 6009, 1, 0, 0, 0, 6009, 6011, 5, 1134, 0, 0, 6010,
		6003, 1, 0, 0, 0, 6010, 6011, 1, 0, 0, 0, 6011, 6012, 1, 0, 0, 0, 6012,
		6013, 5, 80, 0, 0, 6013, 6014, 3, 584, 292, 0, 6014, 507, 1, 0, 0, 0, 6015,
		6017, 5, 432, 0, 0, 6016, 6018, 7, 72, 0, 0, 6017, 6016, 1, 0, 0, 0, 6017,
		6018, 1, 0, 0, 0, 6018, 6019, 1, 0, 0, 0, 6019, 6024, 3, 520, 260, 0, 6020,
		6021, 5, 1135, 0, 0, 6021, 6023, 3, 520, 260, 0, 6022, 6020, 1, 0, 0, 0,
		6023, 6026, 1, 0, 0, 0, 6024, 6022, 1, 0, 0, 0, 6024, 6025, 1, 0, 0, 0,
		6025, 509, 1, 0, 0, 0, 6026, 6024, 1, 0, 0, 0, 6027, 6029, 5, 93, 0, 0,
		6028, 6030, 7, 85, 0, 0, 6029, 6028, 1, 0, 0, 0, 6029, 6030, 1, 0, 0, 0,
		6030, 6031, 1, 0, 0, 0, 6031, 6032, 3, 688, 344, 0, 6032, 511, 1, 0, 0,
		0, 6033, 6034, 5, 102, 0, 0, 6034, 6035, 5, 81, 0, 0, 6035, 6036, 5, 87,
		0, 0, 6036, 6037, 5, 351, 0, 0, 6037, 6042, 3, 524, 262, 0, 6038, 6039,
		5, 1135, 0, 0, 6039, 6041, 3, 524, 262, 0, 6040, 6038, 1, 0, 0, 0, 6041,
		6044, 1, 0, 0, 0, 6042, 6040, 1, 0, 0, 0, 6042, 6043, 1, 0, 0, 0, 6043,
		513, 1, 0, 0, 0, 6044, 6042, 1, 0, 0, 0, 6045, 6046, 5, 589, 0, 0, 6046,
		6047, 5, 567, 0, 0, 6047, 6048, 5, 351, 0, 0, 6048, 515, 1, 0, 0, 0, 6049,
		6050, 5, 739, 0, 0, 6050, 517, 1, 0, 0, 0, 6051, 6059, 3, 552, 276, 0,
		6052, 6054, 7, 20, 0, 0, 6053, 6052, 1, 0, 0, 0, 6053, 6054, 1, 0, 0, 0,
		6054, 6055, 1, 0, 0, 0, 6055, 6056, 5, 1133, 0, 0, 6056, 6057, 3, 616,
		308, 0, 6057, 6058, 5, 1134, 0, 0, 6058, 6060, 1, 0, 0, 0, 6059, 6053,
		1, 0, 0, 0, 6059, 6060, 1, 0, 0, 0, 6060, 519, 1, 0, 0, 0, 6061, 6080,
		5, 394, 0, 0, 6062, 6080, 5, 447, 0, 0, 6063, 6065, 7, 86, 0, 0, 6064,
		6063, 1, 0, 0, 0, 6064, 6065, 1, 0, 0, 0, 6065, 6066, 1, 0, 0, 0, 6066,
		6080, 5, 476, 0, 0, 6067, 6080, 5, 540, 0, 0, 6068, 6080, 5, 725, 0, 0,
		6069, 6070, 5, 567, 0, 0, 6070, 6080, 5, 351, 0, 0, 6071, 6080, 5, 634,
		0, 0, 6072, 6080, 5, 667, 0, 0, 6073, 6077, 5, 742, 0, 0, 6074, 6075, 5,
		192, 0, 0, 6075, 6076, 5, 134, 0, 0, 6076, 6078, 5, 103, 0, 0, 6077, 6074,
		1, 0, 0, 0, 6077, 6078, 1, 0, 0, 0, 6078, 6080, 1, 0, 0, 0, 6079, 6061,
		1, 0, 0, 0, 6079, 6062, 1, 0, 0, 0, 6079, 6064, 1, 0, 0, 0, 6079, 6067,
		1, 0, 0, 0, 6079, 6068, 1, 0, 0, 0, 6079, 6069, 1, 0, 0, 0, 6079, 6071,
		1, 0, 0, 0, 6079, 6072, 1, 0, 0, 0, 6079, 6073, 1, 0, 0, 0, 6080, 6094,
		1, 0, 0, 0, 6081, 6082, 5, 574, 0, 0, 6082, 6084, 5, 476, 0, 0, 6083, 6085,
		3, 356, 178, 0, 6084, 6083, 1, 0, 0, 0, 6084, 6085, 1, 0, 0, 0, 6085, 6094,
		1, 0, 0, 0, 6086, 6088, 7, 54, 0, 0, 6087, 6089, 3, 620, 310, 0, 6088,
		6087, 1, 0, 0, 0, 6088, 6089, 1, 0, 0, 0, 6089, 6091, 1, 0, 0, 0, 6090,
		6092, 3, 522, 261, 0, 6091, 6090, 1, 0, 0, 0, 6091, 6092, 1, 0, 0, 0, 6092,
		6094, 1, 0, 0, 0, 6093, 6079, 1, 0, 0, 0, 6093, 6081, 1, 0, 0, 0, 6093,
		6086, 1, 0, 0, 0, 6094, 521, 1, 0, 0, 0, 6095, 6096, 5, 192, 0, 0, 6096,
		6097, 5, 134, 0, 0, 6097, 6101, 5, 103, 0, 0, 6098, 6099, 5, 65, 0, 0,
		6099, 6101, 5, 421, 0, 0, 6100, 6095, 1, 0, 0, 0, 6100, 6098, 1, 0, 0,
		0, 6101, 523, 1, 0, 0, 0, 6102, 6110, 3, 552, 276, 0, 6103, 6104, 5, 129,
		0, 0, 6104, 6107, 5, 1133, 0, 0, 6105, 6108, 3, 616, 308, 0, 6106, 6108,
		5, 6, 0, 0, 6107, 6105, 1, 0, 0, 0, 6107, 6106, 1, 0, 0, 0, 6108, 6109,
		1, 0, 0, 0, 6109, 6111, 5, 1134, 0, 0, 6110, 6103, 1, 0, 0, 0, 6110, 6111,
		1, 0, 0, 0, 6111, 6119, 1, 0, 0, 0, 6112, 6114, 7, 20, 0, 0, 6113, 6112,
		1, 0, 0, 0, 6113, 6114, 1, 0, 0, 0, 6114, 6115, 1, 0, 0, 0, 6115, 6116,
		5, 1133, 0, 0, 6116, 6117, 3, 616, 308, 0, 6117, 6118, 5, 1134, 0, 0, 6118,
		6120, 1, 0, 0, 0, 6119, 6113, 1, 0, 0, 0, 6119, 6120, 1, 0, 0, 0, 6120,
		6123, 1, 0, 0, 0, 6121, 6122, 5, 78, 0, 0, 6122, 6124, 5, 470, 0, 0, 6123,
		6121, 1, 0, 0, 0, 6123, 6124, 1, 0, 0, 0, 6124, 525, 1, 0, 0, 0, 6125,
		6126, 7, 87, 0, 0, 6126, 6129, 3, 552, 276, 0, 6127, 6130, 3, 584, 292,
		0, 6128, 6130, 5, 1148, 0, 0, 6129, 6127, 1, 0, 0, 0, 6129, 6128, 1, 0,
		0, 0, 6129, 6130, 1, 0, 0, 0, 6130, 527, 1, 0, 0, 0, 6131, 6135, 7, 87,
		0, 0, 6132, 6133, 7, 88, 0, 0, 6133, 6134, 5, 1124, 0, 0, 6134, 6136, 7,
		89, 0, 0, 6135, 6132, 1, 0, 0, 0, 6135, 6136, 1, 0, 0, 0, 6136, 6137, 1,
		0, 0, 0, 6137, 6138, 3, 548, 274, 0, 6138, 529, 1, 0, 0, 0, 6139, 6140,
		5, 444, 0, 0, 6140, 6141, 5, 1148, 0, 0, 6141, 531, 1, 0, 0, 0, 6142, 6143,
		5, 186, 0, 0, 6143, 6144, 3, 584, 292, 0, 6144, 533, 1, 0, 0, 0, 6145,
		6153, 5, 156, 0, 0, 6146, 6148, 5, 162, 0, 0, 6147, 6149, 5, 669, 0, 0,
		6148, 6147, 1, 0, 0, 0, 6148, 6149, 1, 0, 0, 0, 6149, 6150, 1, 0, 0, 0,
		6150, 6154, 3, 594, 297, 0, 6151, 6154, 5, 1156, 0, 0, 6152, 6154, 5, 1157,
		0, 0, 6153, 6146, 1, 0, 0, 0, 6153, 6151, 1, 0, 0, 0, 6153, 6152, 1, 0,
		0, 0, 6154, 6164, 1, 0, 0, 0, 6155, 6156, 5, 153, 0, 0, 6156, 6161, 3,
		538, 269, 0, 6157, 6158, 5, 1135, 0, 0, 6158, 6160, 3, 538, 269, 0, 6159,
		6157, 1, 0, 0, 0, 6160, 6163, 1, 0, 0, 0, 6161, 6159, 1, 0, 0, 0, 6161,
		6162, 1, 0, 0, 0, 6162, 6165, 1, 0, 0, 0, 6163, 6161, 1, 0, 0, 0, 6164,
		6155, 1, 0, 0, 0, 6164, 6165, 1, 0, 0, 0, 6165, 535, 1, 0, 0, 0, 6166,
		6174, 5, 143, 0, 0, 6167, 6169, 5, 162, 0, 0, 6168, 6170, 5, 669, 0, 0,
		6169, 6168, 1, 0, 0, 0, 6169, 6170, 1, 0, 0, 0, 6170, 6171, 1, 0, 0, 0,
		6171, 6175, 3, 594, 297, 0, 6172, 6175, 5, 1156, 0, 0, 6173, 6175, 5, 1157,
		0, 0, 6174, 6167, 1, 0, 0, 0, 6174, 6172, 1, 0, 0, 0, 6174, 6173, 1, 0,
		0, 0, 6174, 6175, 1, 0, 0, 0, 6175, 6185, 1, 0, 0, 0, 6176, 6177, 5, 153,
		0, 0, 6177, 6182, 3, 538, 269, 0, 6178, 6179, 5, 1135, 0, 0, 6179, 6181,
		3, 538, 269, 0, 6180, 6178, 1, 0, 0, 0, 6181, 6184, 1, 0, 0, 0, 6182, 6180,
		1, 0, 0, 0, 6182, 6183, 1, 0, 0, 0, 6183, 6186, 1, 0, 0, 0, 6184, 6182,
		1, 0, 0, 0, 6185, 6176, 1, 0, 0, 0, 6185, 6186, 1, 0, 0, 0, 6186, 537,
		1, 0, 0, 0, 6187, 6188, 7, 90, 0, 0, 6188, 6193, 5, 1124, 0, 0, 6189, 6194,
		3, 594, 297, 0, 6190, 6194, 5, 1149, 0, 0, 6191, 6194, 3, 566, 283, 0,
		6192, 6194, 3, 586, 293, 0, 6193, 6189, 1, 0, 0, 0, 6193, 6190, 1, 0, 0,
		0, 6193, 6191, 1, 0, 0, 0, 6193, 6192, 1, 0, 0, 0, 6194, 539, 1, 0, 0,
		0, 6195, 6197, 5, 192, 0, 0, 6196, 6198, 5, 571, 0, 0, 6197, 6196, 1, 0,
		0, 0, 6197, 6198, 1, 0, 0, 0, 6198, 6199, 1, 0, 0, 0, 6199, 6204, 3, 50,
		25, 0, 6200, 6201, 5, 1135, 0, 0, 6201, 6203, 3, 50, 25, 0, 6202, 6200,
		1, 0, 0, 0, 6203, 6206, 1, 0, 0, 0, 6204, 6202, 1, 0, 0, 0, 6204, 6205,
		1, 0, 0, 0, 6205, 541, 1, 0, 0, 0, 6206, 6204, 1, 0, 0, 0, 6207, 6208,
		5, 172, 0, 0, 6208, 6210, 3, 552, 276, 0, 6209, 6211, 3, 230, 115, 0, 6210,
		6209, 1, 0, 0, 0, 6210, 6211, 1, 0, 0, 0, 6211, 6213, 1, 0, 0, 0, 6212,
		6214, 3, 294, 147, 0, 6213, 6212, 1, 0, 0, 0, 6213, 6214, 1, 0, 0, 0, 6214,
		543, 1, 0, 0, 0, 6215, 6217, 5, 71, 0, 0, 6216, 6218, 7, 91, 0, 0, 6217,
		6216, 1, 0, 0, 0, 6217, 6218, 1, 0, 0, 0, 6218, 6219, 1, 0, 0, 0, 6219,
		6251, 5, 48, 0, 0, 6220, 6221, 3, 492, 246, 0, 6221, 6222, 5, 1124, 0,
		0, 6222, 6230, 7, 92, 0, 0, 6223, 6224, 5, 1135, 0, 0, 6224, 6225, 3, 492,
		246, 0, 6225, 6226, 5, 1124, 0, 0, 6226, 6227, 7, 92, 0, 0, 6227, 6229,
		1, 0, 0, 0, 6228, 6223, 1, 0, 0, 0, 6229, 6232, 1, 0, 0, 0, 6230, 6228,
		1, 0, 0, 0, 6230, 6231, 1, 0, 0, 0, 6231, 6252, 1, 0, 0, 0, 6232, 6230,
		1, 0, 0, 0, 6233, 6236, 5, 29, 0, 0, 6234, 6237, 3, 590, 295, 0, 6235,
		6237, 3, 492, 246, 0, 6236, 6234, 1, 0, 0, 0, 6236, 6235, 1, 0, 0, 0, 6237,
		6238, 1, 0, 0, 0, 6238, 6239, 3, 492, 246, 0, 6239, 6240, 5, 1124, 0, 0,
		6240, 6248, 3, 546, 273, 0, 6241, 6242, 5, 1135, 0, 0, 6242, 6243, 3, 492,
		246, 0, 6243, 6244, 5, 1124, 0, 0, 6244, 6245, 3, 546, 273, 0, 6245, 6247,
		1, 0, 0, 0, 6246, 6241, 1, 0, 0, 0, 6247, 6250, 1, 0, 0, 0, 6248, 6246,
		1, 0, 0, 0, 6248, 6249, 1, 0, 0, 0, 6249, 6252, 1, 0, 0, 0, 6250, 6248,
		1, 0, 0, 0, 6251, 6220, 1, 0, 0, 0, 6251, 6233, 1, 0, 0, 0, 6252, 545,
		1, 0, 0, 0, 6253, 6254, 7, 93, 0, 0, 6254, 547, 1, 0, 0, 0, 6255, 6261,
		3, 200, 100, 0, 6256, 6261, 3, 186, 93, 0, 6257, 6261, 3, 192, 96, 0, 6258,
		6261, 3, 198, 99, 0, 6259, 6261, 3, 202, 101, 0, 6260, 6255, 1, 0, 0, 0,
		6260, 6256, 1, 0, 0, 0, 6260, 6257, 1, 0, 0, 0, 6260, 6258, 1, 0, 0, 0,
		6260, 6259, 1, 0, 0, 0, 6261, 6266, 1, 0, 0, 0, 6262, 6263, 5, 65, 0, 0,
		6263, 6264, 5, 376, 0, 0, 6264, 6266, 3, 584, 292, 0, 6265, 6260, 1, 0,
		0, 0, 6265, 6262, 1, 0, 0, 0, 6266, 549, 1, 0, 0, 0, 6267, 6271, 3, 584,
		292, 0, 6268, 6272, 5, 1155, 0, 0, 6269, 6270, 5, 1132, 0, 0, 6270, 6272,
		3, 584, 292, 0, 6271, 6268, 1, 0, 0, 0, 6271, 6269, 1, 0, 0, 0, 6271, 6272,
		1, 0, 0, 0, 6272, 551, 1, 0, 0, 0, 6273, 6274, 3, 550, 275, 0, 6274, 553,
		1, 0, 0, 0, 6275, 6278, 3, 564, 282, 0, 6276, 6278, 3, 584, 292, 0, 6277,
		6275, 1, 0, 0, 0, 6277, 6276, 1, 0, 0, 0, 6278, 555, 1, 0, 0, 0, 6279,
		6284, 3, 584, 292, 0, 6280, 6282, 3, 588, 294, 0, 6281, 6283, 3, 588, 294,
		0, 6282, 6281, 1, 0, 0, 0, 6282, 6283, 1, 0, 0, 0, 6283, 6285, 1, 0, 0,
		0, 6284, 6280, 1, 0, 0, 0, 6284, 6285, 1, 0, 0, 0, 6285, 6294, 1, 0, 0,
		0, 6286, 6288, 9, 0, 0, 0, 6287, 6286, 1, 0, 0, 0, 6287, 6288, 1, 0, 0,
		0, 6288, 6289, 1, 0, 0, 0, 6289, 6291, 3, 588, 294, 0, 6290, 6292, 3, 588,
		294, 0, 6291, 6290, 1, 0, 0, 0, 6291, 6292, 1, 0, 0, 0, 6292, 6294, 1,
		0, 0, 0, 6293, 6279, 1, 0, 0, 0, 6293, 6287, 1, 0, 0, 0, 6294, 557, 1,
		0, 0, 0, 6295, 6298, 3, 584, 292, 0, 6296, 6298, 5, 1148, 0, 0, 6297, 6295,
		1, 0, 0, 0, 6297, 6296, 1, 0, 0, 0, 6298, 6303, 1, 0, 0, 0, 6299, 6300,
		5, 1133, 0, 0, 6300, 6301, 3, 590, 295, 0, 6301, 6302, 5, 1134, 0, 0, 6302,
		6304, 1, 0, 0, 0, 6303, 6299, 1, 0, 0, 0, 6303, 6304, 1, 0, 0, 0, 6304,
		6307, 1, 0, 0, 0, 6305, 6307, 3, 688, 344, 0, 6306, 6297, 1, 0, 0, 0, 6306,
		6305, 1, 0, 0, 0, 6307, 6309, 1, 0, 0, 0, 6308, 6310, 7, 48, 0, 0, 6309,
		6308, 1, 0, 0, 0, 6309, 6310, 1, 0, 0, 0, 6310, 559, 1, 0, 0, 0, 6311,
		6316, 5, 1148, 0, 0, 6312, 6316, 5, 1156, 0, 0, 6313, 6316, 5, 697, 0,
		0, 6314, 6316, 3, 718, 359, 0, 6315, 6311, 1, 0, 0, 0, 6315, 6312, 1, 0,
		0, 0, 6315, 6313, 1, 0, 0, 0, 6315, 6314, 1, 0, 0, 0, 6316, 561, 1, 0,
		0, 0, 6317, 6318, 7, 94, 0, 0, 6318, 563, 1, 0, 0, 0, 6319, 6325, 3, 560,
		280, 0, 6320, 6321, 3, 560, 280, 0, 6321, 6322, 3, 562, 281, 0, 6322, 6325,
		1, 0, 0, 0, 6323, 6325, 3, 62, 31, 0, 6324, 6319, 1, 0, 0, 0, 6324, 6320,
		1, 0, 0, 0, 6324, 6323, 1, 0, 0, 0, 6325, 565, 1, 0, 0, 0, 6326, 6327,
		7, 95, 0, 0, 6327, 567, 1, 0, 0, 0, 6328, 6333, 5, 226, 0, 0, 6329, 6333,
		3, 708, 354, 0, 6330, 6333, 5, 1148, 0, 0, 6331, 6333, 5, 1145, 0, 0, 6332,
		6328, 1, 0, 0, 0, 6332, 6329, 1, 0, 0, 0, 6332, 6330, 1, 0, 0, 0, 6332,
		6331, 1, 0, 0, 0, 6333, 569, 1, 0, 0, 0, 6334, 6337, 3, 584, 292, 0, 6335,
		6337, 5, 1148, 0, 0, 6336, 6334, 1, 0, 0, 0, 6336, 6335, 1, 0, 0, 0, 6337,
		571, 1, 0, 0, 0, 6338, 6342, 3, 574, 287, 0, 6339, 6342, 5, 1156, 0, 0,
		6340, 6342, 5, 1148, 0, 0, 6341, 6338, 1, 0, 0, 0, 6341, 6339, 1, 0, 0,
		0, 6341, 6340, 1, 0, 0, 0, 6342, 573, 1, 0, 0, 0, 6343, 6344, 7, 96, 0,
		0, 6344, 575, 1, 0, 0, 0, 6345, 6346, 3, 590, 295, 0, 6346, 6347, 5, 1121,
		0, 0, 6347, 6348, 3, 590, 295, 0, 6348, 6349, 5, 1121, 0, 0, 6349, 6350,
		3, 590, 295, 0, 6350, 6351, 5, 1121, 0, 0, 6351, 6352, 3, 590, 295, 0,
		6352, 6353, 5, 1121, 0, 0, 6353, 6359, 3, 590, 295, 0, 6354, 6355, 5, 1144,
		0, 0, 6355, 6356, 3, 590, 295, 0, 6356, 6357, 5, 1121, 0, 0, 6357, 6358,
		3, 590, 295, 0, 6358, 6360, 1, 0, 0, 0, 6359, 6354, 1, 0, 0, 0, 6360, 6361,
		1, 0, 0, 0, 6361, 6359, 1, 0, 0, 0, 6361, 6362, 1, 0, 0, 0, 6362, 577,
		1, 0, 0, 0, 6363, 6370, 3, 580, 290, 0, 6364, 6365, 5, 1135, 0, 0, 6365,
		6368, 3, 580, 290, 0, 6366, 6367, 5, 1135, 0, 0, 6367, 6369, 3, 590, 295,
		0, 6368, 6366, 1, 0, 0, 0, 6368, 6369, 1, 0, 0, 0, 6369, 6371, 1, 0, 0,
		0, 6370, 6364, 1, 0, 0, 0, 6370, 6371, 1, 0, 0, 0, 6371, 579, 1, 0, 0,
		0, 6372, 6380, 5, 1148, 0, 0, 6373, 6380, 5, 1153, 0, 0, 6374, 6376, 5,
		1150, 0, 0, 6375, 6374, 1, 0, 0, 0, 6376, 6377, 1, 0, 0, 0, 6377, 6375,
		1, 0, 0, 0, 6377, 6378, 1, 0, 0, 0, 6378, 6380, 1, 0, 0, 0, 6379, 6372,
		1, 0, 0, 0, 6379, 6373, 1, 0, 0, 0, 6379, 6375, 1, 0, 0, 0, 6380, 581,
		1, 0, 0, 0, 6381, 6384, 3, 584, 292, 0, 6382, 6384, 5, 1148, 0, 0, 6383,
		6381, 1, 0, 0, 0, 6383, 6382, 1, 0, 0, 0, 6384, 583, 1, 0, 0, 0, 6385,
		6389, 3, 586, 293, 0, 6386, 6389, 5, 1145, 0, 0, 6387, 6389, 5, 1148, 0,
		0, 6388, 6385, 1, 0, 0, 0, 6388, 6386, 1, 0, 0, 0, 6388, 6387, 1, 0, 0,
		0, 6389, 585, 1, 0, 0, 0, 6390, 6400, 5, 1156, 0, 0, 6391, 6400, 3, 708,
		354, 0, 6392, 6400, 3, 710, 355, 0, 6393, 6400, 3, 574, 287, 0, 6394, 6400,
		3, 712, 356, 0, 6395, 6400, 3, 714, 357, 0, 6396, 6400, 3, 716, 358, 0,
		6397, 6400, 3, 718, 359, 0, 6398, 6400, 3, 680, 340, 0, 6399, 6390, 1,
		0, 0, 0, 6399, 6391, 1, 0, 0, 0, 6399, 6392, 1, 0, 0, 0, 6399, 6393, 1,
		0, 0, 0, 6399, 6394, 1, 0, 0, 0, 6399, 6395, 1, 0, 0, 0, 6399, 6396, 1,
		0, 0, 0, 6399, 6397, 1, 0, 0, 0, 6399, 6398, 1, 0, 0, 0, 6400, 587, 1,
		0, 0, 0, 6401, 6405, 5, 1155, 0, 0, 6402, 6403, 5, 1132, 0, 0, 6403, 6405,
		3, 584, 292, 0, 6404, 6401, 1, 0, 0, 0, 6404, 6402, 1, 0, 0, 0, 6405, 589,
		1, 0, 0, 0, 6406, 6407, 7, 97, 0, 0, 6407, 591, 1, 0, 0, 0, 6408, 6411,
		5, 1146, 0, 0, 6409, 6411, 3, 590, 295, 0, 6410, 6408, 1, 0, 0, 0, 6410,
		6409, 1, 0, 0, 0, 6411, 593, 1, 0, 0, 0, 6412, 6414, 5, 1154, 0, 0, 6413,
		6412, 1, 0, 0, 0, 6413, 6414, 1, 0, 0, 0, 6414, 6415, 1, 0, 0, 0, 6415,
		6418, 5, 1148, 0, 0, 6416, 6418, 5, 1147, 0, 0, 6417, 6413, 1, 0, 0, 0,
		6417, 6416, 1, 0, 0, 0, 6418, 6420, 1, 0, 0, 0, 6419, 6421, 5, 1148, 0,
		0, 6420, 6419, 1, 0, 0, 0, 6421, 6422, 1, 0, 0, 0, 6422, 6420, 1, 0, 0,
		0, 6422, 6423, 1, 0, 0, 0, 6423, 6436, 1, 0, 0, 0, 6424, 6426, 5, 1154,
		0, 0, 6425, 6424, 1, 0, 0, 0, 6425, 6426, 1, 0, 0, 0, 6426, 6427, 1, 0,
		0, 0, 6427, 6430, 5, 1148, 0, 0, 6428, 6430, 5, 1147, 0, 0, 6429, 6425,
		1, 0, 0, 0, 6429, 6428, 1, 0, 0, 0, 6430, 6433, 1, 0, 0, 0, 6431, 6432,
		5, 27, 0, 0, 6432, 6434, 3, 570, 285, 0, 6433, 6431, 1, 0, 0, 0, 6433,
		6434, 1, 0, 0, 0, 6434, 6436, 1, 0, 0, 0, 6435, 6417, 1, 0, 0, 0, 6435,
		6429, 1, 0, 0, 0, 6436, 595, 1, 0, 0, 0, 6437, 6438, 7, 98, 0, 0, 6438,
		597, 1, 0, 0, 0, 6439, 6441, 5, 1154, 0, 0, 6440, 6439, 1, 0, 0, 0, 6440,
		6441, 1, 0, 0, 0, 6441, 6442, 1, 0, 0, 0, 6442, 6443, 5, 1150, 0, 0, 6443,
		599, 1, 0, 0, 0, 6444, 6446, 5, 114, 0, 0, 6445, 6444, 1, 0, 0, 0, 6445,
		6446, 1, 0, 0, 0, 6446, 6447, 1, 0, 0, 0, 6447, 6448, 7, 99, 0, 0, 6448,
		601, 1, 0, 0, 0, 6449, 6462, 3, 594, 297, 0, 6450, 6462, 3, 590, 295, 0,
		6451, 6452, 5, 1121, 0, 0, 6452, 6462, 3, 590, 295, 0, 6453, 6462, 3, 598,
		299, 0, 6454, 6462, 3, 596, 298, 0, 6455, 6462, 5, 1151, 0, 0, 6456, 6462,
		5, 1153, 0, 0, 6457, 6459, 5, 114, 0, 0, 6458, 6457, 1, 0, 0, 0, 6458,
		6459, 1, 0, 0, 0, 6459, 6460, 1, 0, 0, 0, 6460, 6462, 7, 99, 0, 0, 6461,
		6449, 1, 0, 0, 0, 6461, 6450, 1, 0, 0, 0, 6461, 6451, 1, 0, 0, 0, 6461,
		6453, 1, 0, 0, 0, 6461, 6454, 1, 0, 0, 0, 6461, 6455, 1, 0, 0, 0, 6461,
		6456, 1, 0, 0, 0, 6461, 6458, 1, 0, 0, 0, 6462, 603, 1, 0, 0, 0, 6463,
		6465, 7, 100, 0, 0, 6464, 6466, 5, 238, 0, 0, 6465, 6464, 1, 0, 0, 0, 6465,
		6466, 1, 0, 0, 0, 6466, 6468, 1, 0, 0, 0, 6467, 6469, 3, 610, 305, 0, 6468,
		6467, 1, 0, 0, 0, 6468, 6469, 1, 0, 0, 0, 6469, 6471, 1, 0, 0, 0, 6470,
		6472, 5, 226, 0, 0, 6471, 6470, 1, 0, 0, 0, 6471, 6472, 1, 0, 0, 0, 6472,
		6476, 1, 0, 0, 0, 6473, 6474, 3, 60, 30, 0, 6474, 6475, 3, 568, 284, 0,
		6475, 6477, 1, 0, 0, 0, 6476, 6473, 1, 0, 0, 0, 6476, 6477, 1, 0, 0, 0,
		6477, 6481, 1, 0, 0, 0, 6478, 6479, 5, 27, 0, 0, 6479, 6482, 3, 570, 285,
		0, 6480, 6482, 5, 226, 0, 0, 6481, 6478, 1, 0, 0, 0, 6481, 6480, 1, 0,
		0, 0, 6481, 6482, 1, 0, 0, 0, 6482, 6590, 1, 0, 0, 0, 6483, 6484, 5, 225,
		0, 0, 6484, 6485, 7, 101, 0, 0, 6485, 6487, 5, 238, 0, 0, 6486, 6488, 3,
		610, 305, 0, 6487, 6486, 1, 0, 0, 0, 6487, 6488, 1, 0, 0, 0, 6488, 6490,
		1, 0, 0, 0, 6489, 6491, 5, 226, 0, 0, 6490, 6489, 1, 0, 0, 0, 6490, 6491,
		1, 0, 0, 0, 6491, 6590, 1, 0, 0, 0, 6492, 6493, 5, 225, 0, 0, 6493, 6495,
		7, 102, 0, 0, 6494, 6496, 3, 610, 305, 0, 6495, 6494, 1, 0, 0, 0, 6495,
		6496, 1, 0, 0, 0, 6496, 6498, 1, 0, 0, 0, 6497, 6499, 5, 226, 0, 0, 6498,
		6497, 1, 0, 0, 0, 6498, 6499, 1, 0, 0, 0, 6499, 6590, 1, 0, 0, 0, 6500,
		6501, 5, 518, 0, 0, 6501, 6503, 5, 223, 0, 0, 6502, 6504, 3, 610, 305,
		0, 6503, 6502, 1, 0, 0, 0, 6503, 6504, 1, 0, 0, 0, 6504, 6506, 1, 0, 0,
		0, 6505, 6507, 5, 226, 0, 0, 6506, 6505, 1, 0, 0, 0, 6506, 6507, 1, 0,
		0, 0, 6507, 6590, 1, 0, 0, 0, 6508, 6510, 7, 103, 0, 0, 6509, 6511, 3,
		610, 305, 0, 6510, 6509, 1, 0, 0, 0, 6510, 6511, 1, 0, 0, 0, 6511, 6515,
		1, 0, 0, 0, 6512, 6514, 7, 104, 0, 0, 6513, 6512, 1, 0, 0, 0, 6514, 6517,
		1, 0, 0, 0, 6515, 6513, 1, 0, 0, 0, 6515, 6516, 1, 0, 0, 0, 6516, 6590,
		1, 0, 0, 0, 6517, 6515, 1, 0, 0, 0, 6518, 6520, 5, 208, 0, 0, 6519, 6521,
		3, 612, 306, 0, 6520, 6519, 1, 0, 0, 0, 6520, 6521, 1, 0, 0, 0, 6521, 6525,
		1, 0, 0, 0, 6522, 6524, 7, 104, 0, 0, 6523, 6522, 1, 0, 0, 0, 6524, 6527,
		1, 0, 0, 0, 6525, 6523, 1, 0, 0, 0, 6525, 6526, 1, 0, 0, 0, 6526, 6590,
		1, 0, 0, 0, 6527, 6525, 1, 0, 0, 0, 6528, 6530, 5, 209, 0, 0, 6529, 6531,
		5, 210, 0, 0, 6530, 6529, 1, 0, 0, 0, 6530, 6531, 1, 0, 0, 0, 6531, 6533,
		1, 0, 0, 0, 6532, 6534, 3, 612, 306, 0, 6533, 6532, 1, 0, 0, 0, 6533, 6534,
		1, 0, 0, 0, 6534, 6538, 1, 0, 0, 0, 6535, 6537, 7, 104, 0, 0, 6536, 6535,
		1, 0, 0, 0, 6537, 6540, 1, 0, 0, 0, 6538, 6536, 1, 0, 0, 0, 6538, 6539,
		1, 0, 0, 0, 6539, 6590, 1, 0, 0, 0, 6540, 6538, 1, 0, 0, 0, 6541, 6543,
		7, 105, 0, 0, 6542, 6544, 3, 614, 307, 0, 6543, 6542, 1, 0, 0, 0, 6543,
		6544, 1, 0, 0, 0, 6544, 6548, 1, 0, 0, 0, 6545, 6547, 7, 104, 0, 0, 6546,
		6545, 1, 0, 0, 0, 6547, 6550, 1, 0, 0, 0, 6548, 6546, 1, 0, 0, 0, 6548,
		6549, 1, 0, 0, 0, 6549, 6590, 1, 0, 0, 0, 6550, 6548, 1, 0, 0, 0, 6551,
		6590, 7, 106, 0, 0, 6552, 6554, 7, 107, 0, 0, 6553, 6555, 3, 610, 305,
		0, 6554, 6553, 1, 0, 0, 0, 6554, 6555, 1, 0, 0, 0, 6555, 6590, 1, 0, 0,
		0, 6556, 6557, 7, 108, 0, 0, 6557, 6559, 3, 606, 303, 0, 6558, 6560, 5,
		226, 0, 0, 6559, 6558, 1, 0, 0, 0, 6559, 6560, 1, 0, 0, 0, 6560, 6564,
		1, 0, 0, 0, 6561, 6562, 3, 60, 30, 0, 6562, 6563, 3, 568, 284, 0, 6563,
		6565, 1, 0, 0, 0, 6564, 6561, 1, 0, 0, 0, 6564, 6565, 1, 0, 0, 0, 6565,
		6590, 1, 0, 0, 0, 6566, 6569, 7, 109, 0, 0, 6567, 6568, 5, 1012, 0, 0,
		6568, 6570, 3, 590, 295, 0, 6569, 6567, 1, 0, 0, 0, 6569, 6570, 1, 0, 0,
		0, 6570, 6590, 1, 0, 0, 0, 6571, 6573, 5, 231, 0, 0, 6572, 6574, 5, 223,
		0, 0, 6573, 6572, 1, 0, 0, 0, 6573, 6574, 1, 0, 0, 0, 6574, 6576, 1, 0,
		0, 0, 6575, 6577, 5, 226, 0, 0, 6576, 6575, 1, 0, 0, 0, 6576, 6577, 1,
		0, 0, 0, 6577, 6581, 1, 0, 0, 0, 6578, 6579, 3, 60, 30, 0, 6579, 6580,
		3, 568, 284, 0, 6580, 6582, 1, 0, 0, 0, 6581, 6578, 1, 0, 0, 0, 6581, 6582,
		1, 0, 0, 0, 6582, 6585, 1, 0, 0, 0, 6583, 6584, 5, 27, 0, 0, 6584, 6586,
		3, 570, 285, 0, 6585, 6583, 1, 0, 0, 0, 6585, 6586, 1, 0, 0, 0, 6586, 6590,
		1, 0, 0, 0, 6587, 6588, 5, 231, 0, 0, 6588, 6590, 5, 227, 0, 0, 6589, 6463,
		1, 0, 0, 0, 6589, 6483, 1, 0, 0, 0, 6589, 6492, 1, 0, 0, 0, 6589, 6500,
		1, 0, 0, 0, 6589, 6508, 1, 0, 0, 0, 6589, 6518, 1, 0, 0, 0, 6589, 6528,
		1, 0, 0, 0, 6589, 6541, 1, 0, 0, 0, 6589, 6551, 1, 0, 0, 0, 6589, 6552,
		1, 0, 0, 0, 6589, 6556, 1, 0, 0, 0, 6589, 6566, 1, 0, 0, 0, 6589, 6571,
		1, 0, 0, 0, 6589, 6587, 1, 0, 0, 0, 6590, 605, 1, 0, 0, 0, 6591, 6592,
		5, 1133, 0, 0, 6592, 6597, 5, 1148, 0, 0, 6593, 6594, 5, 1135, 0, 0, 6594,
		6596, 5, 1148, 0, 0, 6595, 6593, 1, 0, 0, 0, 6596, 6599, 1, 0, 0, 0, 6597,
		6595, 1, 0, 0, 0, 6597, 6598, 1, 0, 0, 0, 6598, 6600, 1, 0, 0, 0, 6599,
		6597, 1, 0, 0, 0, 6600, 6601, 5, 1134, 0, 0, 6601, 607, 1, 0, 0, 0, 6602,
		6604, 7, 110, 0, 0, 6603, 6605, 3, 610, 305, 0, 6604, 6603, 1, 0, 0, 0,
		6604, 6605, 1, 0, 0, 0, 6605, 6625, 1, 0, 0, 0, 6606, 6608, 5, 222, 0,
		0, 6607, 6609, 3, 610, 305, 0, 6608, 6607, 1, 0, 0, 0, 6608, 6609, 1, 0,
		0, 0, 6609, 6613, 1, 0, 0, 0, 6610, 6611, 3, 60, 30, 0, 6611, 6612, 3,
		568, 284, 0, 6612, 6614, 1, 0, 0, 0, 6613, 6610, 1, 0, 0, 0, 6613, 6614,
		1, 0, 0, 0, 6614, 6625, 1, 0, 0, 0, 6615, 6625, 7, 111, 0, 0, 6616, 6618,
		7, 112, 0, 0, 6617, 6619, 3, 614, 307, 0, 6618, 6617, 1, 0, 0, 0, 6618,
		6619, 1, 0, 0, 0, 6619, 6625, 1, 0, 0, 0, 6620, 6622, 7, 113, 0, 0, 6621,
		6623, 7, 114, 0, 0, 6622, 6621, 1, 0, 0, 0, 6622, 6623, 1, 0, 0, 0, 6623,
		6625, 1, 0, 0, 0, 6624, 6602, 1, 0, 0, 0, 6624, 6606, 1, 0, 0, 0, 6624,
		6615, 1, 0, 0, 0, 6624, 6616, 1, 0, 0, 0, 6624, 6620, 1, 0, 0, 0, 6625,
		6627, 1, 0, 0, 0, 6626, 6628, 5, 11, 0, 0, 6627, 6626, 1, 0, 0, 0, 6627,
		6628, 1, 0, 0, 0, 6628, 609, 1, 0, 0, 0, 6629, 6630, 5, 1133, 0, 0, 6630,
		6631, 3, 590, 295, 0, 6631, 6632, 5, 1134, 0, 0, 6632, 611, 1, 0, 0, 0,
		6633, 6634, 5, 1133, 0, 0, 6634, 6635, 3, 590, 295, 0, 6635, 6636, 5, 1135,
		0, 0, 6636, 6637, 3, 590, 295, 0, 6637, 6638, 5, 1134, 0, 0, 6638, 613,
		1, 0, 0, 0, 6639, 6640, 5, 1133, 0, 0, 6640, 6643, 3, 590, 295, 0, 6641,
		6642, 5, 1135, 0, 0, 6642, 6644, 3, 590, 295, 0, 6643, 6641, 1, 0, 0, 0,
		6643, 6644, 1, 0, 0, 0, 6644, 6645, 1, 0, 0, 0, 6645, 6646, 5, 1134, 0,
		0, 6646, 615, 1, 0, 0, 0, 6647, 6652, 3, 584, 292, 0, 6648, 6649, 5, 1135,
		0, 0, 6649, 6651, 3, 584, 292, 0, 6650, 6648, 1, 0, 0, 0, 6651, 6654, 1,
		0, 0, 0, 6652, 6650, 1, 0, 0, 0, 6652, 6653, 1, 0, 0, 0, 6653, 617, 1,
		0, 0, 0, 6654, 6652, 1, 0, 0, 0, 6655, 6660, 3, 556, 278, 0, 6656, 6657,
		5, 1135, 0, 0, 6657, 6659, 3, 556, 278, 0, 6658, 6656, 1, 0, 0, 0, 6659,
		6662, 1, 0, 0, 0, 6660, 6658, 1, 0, 0, 0, 6660, 6661, 1, 0, 0, 0, 6661,
		619, 1, 0, 0, 0, 6662, 6660, 1, 0, 0, 0, 6663, 6668, 3, 552, 276, 0, 6664,
		6665, 5, 1135, 0, 0, 6665, 6667, 3, 552, 276, 0, 6666, 6664, 1, 0, 0, 0,
		6667, 6670, 1, 0, 0, 0, 6668, 6666, 1, 0, 0, 0, 6668, 6669, 1, 0, 0, 0,
		6669, 621, 1, 0, 0, 0, 6670, 6668, 1, 0, 0, 0, 6671, 6672, 5, 1133, 0,
		0, 6672, 6677, 3, 558, 279, 0, 6673, 6674, 5, 1135, 0, 0, 6674, 6676, 3,
		558, 279, 0, 6675, 6673, 1, 0, 0, 0, 6676, 6679, 1, 0, 0, 0, 6677, 6675,
		1, 0, 0, 0, 6677, 6678, 1, 0, 0, 0, 6678, 6680, 1, 0, 0, 0, 6679, 6677,
		1, 0, 0, 0, 6680, 6681, 5, 1134, 0, 0, 6681, 623, 1, 0, 0, 0, 6682, 6687,
		3, 688, 344, 0, 6683, 6684, 5, 1135, 0, 0, 6684, 6686, 3, 688, 344, 0,
		6685, 6683, 1, 0, 0, 0, 6686, 6689, 1, 0, 0, 0, 6687, 6685, 1, 0, 0, 0,
		6687, 6688, 1, 0, 0, 0, 6688, 625, 1, 0, 0, 0, 6689, 6687, 1, 0, 0, 0,
		6690, 6695, 3, 638, 319, 0, 6691, 6692, 5, 1135, 0, 0, 6692, 6694, 3, 638,
		319, 0, 6693, 6691, 1, 0, 0, 0, 6694, 6697, 1, 0, 0, 0, 6695, 6693, 1,
		0, 0, 0, 6695, 6696, 1, 0, 0, 0, 6696, 627, 1, 0, 0, 0, 6697, 6695, 1,
		0, 0, 0, 6698, 6703, 3, 602, 301, 0, 6699, 6700, 5, 1135, 0, 0, 6700, 6702,
		3, 602, 301, 0, 6701, 6699, 1, 0, 0, 0, 6702, 6705, 1, 0, 0, 0, 6703, 6701,
		1, 0, 0, 0, 6703, 6704, 1, 0, 0, 0, 6704, 629, 1, 0, 0, 0, 6705, 6703,
		1, 0, 0, 0, 6706, 6711, 5, 1148, 0, 0, 6707, 6708, 5, 1135, 0, 0, 6708,
		6710, 5, 1148, 0, 0, 6709, 6707, 1, 0, 0, 0, 6710, 6713, 1, 0, 0, 0, 6711,
		6709, 1, 0, 0, 0, 6711, 6712, 1, 0, 0, 0, 6712, 631, 1, 0, 0, 0, 6713,
		6711, 1, 0, 0, 0, 6714, 6719, 5, 1159, 0, 0, 6715, 6716, 5, 1135, 0, 0,
		6716, 6718, 5, 1159, 0, 0, 6717, 6715, 1, 0, 0, 0, 6718, 6721, 1, 0, 0,
		0, 6719, 6717, 1, 0, 0, 0, 6719, 6720, 1, 0, 0, 0, 6720, 633, 1, 0, 0,
		0, 6721, 6719, 1, 0, 0, 0, 6722, 6749, 5, 116, 0, 0, 6723, 6724, 5, 23,
		0, 0, 6724, 6725, 5, 1133, 0, 0, 6725, 6726, 3, 688, 344, 0, 6726, 6727,
		5, 12, 0, 0, 6727, 6728, 3, 608, 304, 0, 6728, 6729, 5, 1134, 0, 0, 6729,
		6749, 1, 0, 0, 0, 6730, 6732, 3, 694, 347, 0, 6731, 6730, 1, 0, 0, 0, 6731,
		6732, 1, 0, 0, 0, 6732, 6733, 1, 0, 0, 0, 6733, 6749, 3, 602, 301, 0, 6734,
		6738, 3, 636, 318, 0, 6735, 6736, 5, 118, 0, 0, 6736, 6737, 5, 184, 0,
		0, 6737, 6739, 3, 636, 318, 0, 6738, 6735, 1, 0, 0, 0, 6738, 6739, 1, 0,
		0, 0, 6739, 6749, 1, 0, 0, 0, 6740, 6741, 5, 1133, 0, 0, 6741, 6742, 3,
		688, 344, 0, 6742, 6743, 5, 1134, 0, 0, 6743, 6749, 1, 0, 0, 0, 6744, 6745,
		5, 1133, 0, 0, 6745, 6746, 3, 550, 275, 0, 6746, 6747, 5, 1134, 0, 0, 6747,
		6749, 1, 0, 0, 0, 6748, 6722, 1, 0, 0, 0, 6748, 6723, 1, 0, 0, 0, 6748,
		6731, 1, 0, 0, 0, 6748, 6734, 1, 0, 0, 0, 6748, 6740, 1, 0, 0, 0, 6748,
		6744, 1, 0, 0, 0, 6749, 635, 1, 0, 0, 0, 6750, 6756, 7, 115, 0, 0, 6751,
		6753, 5, 1133, 0, 0, 6752, 6754, 3, 590, 295, 0, 6753, 6752, 1, 0, 0, 0,
		6753, 6754, 1, 0, 0, 0, 6754, 6755, 1, 0, 0, 0, 6755, 6757, 5, 1134, 0,
		0, 6756, 6751, 1, 0, 0, 0, 6756, 6757, 1, 0, 0, 0, 6757, 6765, 1, 0, 0,
		0, 6758, 6759, 5, 323, 0, 0, 6759, 6761, 5, 1133, 0, 0, 6760, 6762, 3,
		590, 295, 0, 6761, 6760, 1, 0, 0, 0, 6761, 6762, 1, 0, 0, 0, 6762, 6763,
		1, 0, 0, 0, 6763, 6765, 5, 1134, 0, 0, 6764, 6750, 1, 0, 0, 0, 6764, 6758,
		1, 0, 0, 0, 6765, 637, 1, 0, 0, 0, 6766, 6769, 3, 688, 344, 0, 6767, 6769,
		5, 42, 0, 0, 6768, 6766, 1, 0, 0, 0, 6768, 6767, 1, 0, 0, 0, 6769, 639,
		1, 0, 0, 0, 6770, 6771, 5, 77, 0, 0, 6771, 6772, 5, 60, 0, 0, 6772, 641,
		1, 0, 0, 0, 6773, 6774, 5, 77, 0, 0, 6774, 6775, 5, 114, 0, 0, 6775, 6776,
		5, 60, 0, 0, 6776, 643, 1, 0, 0, 0, 6777, 6778, 5, 123, 0, 0, 6778, 6779,
		5, 141, 0, 0, 6779, 645, 1, 0, 0, 0, 6780, 6781, 5, 674, 0, 0, 6781, 6784,
		3, 590, 295, 0, 6782, 6784, 5, 527, 0, 0, 6783, 6780, 1, 0, 0, 0, 6783,
		6782, 1, 0, 0, 0, 6784, 647, 1, 0, 0, 0, 6785, 6804, 3, 650, 325, 0, 6786,
		6804, 3, 658, 329, 0, 6787, 6804, 3, 660, 330, 0, 6788, 6789, 3, 680, 340,
		0, 6789, 6791, 5, 1133, 0, 0, 6790, 6792, 3, 684, 342, 0, 6791, 6790, 1,
		0, 0, 0, 6791, 6792, 1, 0, 0, 0, 6792, 6793, 1, 0, 0, 0, 6793, 6794, 5,
		1134, 0, 0, 6794, 6804, 1, 0, 0, 0, 6795, 6796, 3, 550, 275, 0, 6796, 6798,
		5, 1133, 0, 0, 6797, 6799, 3, 684, 342, 0, 6798, 6797, 1, 0, 0, 0, 6798,
		6799, 1, 0, 0, 0, 6799, 6800, 1, 0, 0, 0, 6800, 6801, 5, 1134, 0, 0, 6801,
		6804, 1, 0, 0, 0, 6802, 6804, 3, 682, 341, 0, 6803, 6785, 1, 0, 0, 0, 6803,
		6786, 1, 0, 0, 0, 6803, 6787, 1, 0, 0, 0, 6803, 6788, 1, 0, 0, 0, 6803,
		6795, 1, 0, 0, 0, 6803, 6802, 1, 0, 0, 0, 6804, 649, 1, 0, 0, 0, 6805,
		6808, 7, 116, 0, 0, 6806, 6807, 5, 1133, 0, 0, 6807, 6809, 5, 1134, 0,
		0, 6808, 6806, 1, 0, 0, 0, 6808, 6809, 1, 0, 0, 0, 6809, 6985, 1, 0, 0,
		0, 6810, 6985, 3, 62, 31, 0, 6811, 6812, 5, 32, 0, 0, 6812, 6813, 5, 1133,
		0, 0, 6813, 6814, 3, 688, 344, 0, 6814, 6815, 5, 1135, 0, 0, 6815, 6816,
		3, 608, 304, 0, 6816, 6817, 5, 1134, 0, 0, 6817, 6985, 1, 0, 0, 0, 6818,
		6819, 5, 32, 0, 0, 6819, 6820, 5, 1133, 0, 0, 6820, 6821, 3, 688, 344,
		0, 6821, 6822, 5, 187, 0, 0, 6822, 6823, 3, 568, 284, 0, 6823, 6824, 5,
		1134, 0, 0, 6824, 6985, 1, 0, 0, 0, 6825, 6826, 5, 23, 0, 0, 6826, 6827,
		5, 1133, 0, 0, 6827, 6828, 3, 688, 344, 0, 6828, 6829, 5, 12, 0, 0, 6829,
		6830, 3, 608, 304, 0, 6830, 6831, 5, 1134, 0, 0, 6831, 6985, 1, 0, 0, 0,
		6832, 6833, 5, 188, 0, 0, 6833, 6834, 5, 1133, 0, 0, 6834, 6835, 3, 556,
		278, 0, 6835, 6836, 5, 1134, 0, 0, 6836, 6985, 1, 0, 0, 0, 6837, 6838,
		5, 22, 0, 0, 6838, 6840, 3, 688, 344, 0, 6839, 6841, 3, 652, 326, 0, 6840,
		6839, 1, 0, 0, 0, 6841, 6842, 1, 0, 0, 0, 6842, 6840, 1, 0, 0, 0, 6842,
		6843, 1, 0, 0, 0, 6843, 6846, 1, 0, 0, 0, 6844, 6845, 5, 53, 0, 0, 6845,
		6847, 3, 686, 343, 0, 6846, 6844, 1, 0, 0, 0, 6846, 6847, 1, 0, 0, 0, 6847,
		6848, 1, 0, 0, 0, 6848, 6849, 5, 407, 0, 0, 6849, 6985, 1, 0, 0, 0, 6850,
		6852, 5, 22, 0, 0, 6851, 6853, 3, 652, 326, 0, 6852, 6851, 1, 0, 0, 0,
		6853, 6854, 1, 0, 0, 0, 6854, 6852, 1, 0, 0, 0, 6854, 6855, 1, 0, 0, 0,
		6855, 6858, 1, 0, 0, 0, 6856, 6857, 5, 53, 0, 0, 6857, 6859, 3, 686, 343,
		0, 6858, 6856, 1, 0, 0, 0, 6858, 6859, 1, 0, 0, 0, 6859, 6860, 1, 0, 0,
		0, 6860, 6861, 5, 407, 0, 0, 6861, 6985, 1, 0, 0, 0, 6862, 6863, 5, 222,
		0, 0, 6863, 6864, 5, 1133, 0, 0, 6864, 6867, 3, 684, 342, 0, 6865, 6866,
		5, 187, 0, 0, 6866, 6868, 3, 568, 284, 0, 6867, 6865, 1, 0, 0, 0, 6867,
		6868, 1, 0, 0, 0, 6868, 6869, 1, 0, 0, 0, 6869, 6870, 5, 1134, 0, 0, 6870,
		6985, 1, 0, 0, 0, 6871, 6872, 5, 324, 0, 0, 6872, 6875, 5, 1133, 0, 0,
		6873, 6876, 3, 594, 297, 0, 6874, 6876, 3, 688, 344, 0, 6875, 6873, 1,
		0, 0, 0, 6875, 6874, 1, 0, 0, 0, 6876, 6877, 1, 0, 0, 0, 6877, 6880, 5,
		80, 0, 0, 6878, 6881, 3, 594, 297, 0, 6879, 6881, 3, 688, 344, 0, 6880,
		6878, 1, 0, 0, 0, 6880, 6879, 1, 0, 0, 0, 6881, 6882, 1, 0, 0, 0, 6882,
		6883, 5, 1134, 0, 0, 6883, 6985, 1, 0, 0, 0, 6884, 6885, 7, 117, 0, 0,
		6885, 6888, 5, 1133, 0, 0, 6886, 6889, 3, 594, 297, 0, 6887, 6889, 3, 688,
		344, 0, 6888, 6886, 1, 0, 0, 0, 6888, 6887, 1, 0, 0, 0, 6889, 6890, 1,
		0, 0, 0, 6890, 6893, 5, 68, 0, 0, 6891, 6894, 3, 590, 295, 0, 6892, 6894,
		3, 688, 344, 0, 6893, 6891, 1, 0, 0, 0, 6893, 6892, 1, 0, 0, 0, 6894, 6900,
		1, 0, 0, 0, 6895, 6898, 5, 65, 0, 0, 6896, 6899, 3, 590, 295, 0, 6897,
		6899, 3, 688, 344, 0, 6898, 6896, 1, 0, 0, 0, 6898, 6897, 1, 0, 0, 0, 6899,
		6901, 1, 0, 0, 0, 6900, 6895, 1, 0, 0, 0, 6900, 6901, 1, 0, 0, 0, 6901,
		6902, 1, 0, 0, 0, 6902, 6903, 5, 1134, 0, 0, 6903, 6985, 1, 0, 0, 0, 6904,
		6905, 5, 328, 0, 0, 6905, 6906, 5, 1133, 0, 0, 6906, 6909, 7, 118, 0, 0,
		6907, 6910, 3, 594, 297, 0, 6908, 6910, 3, 688, 344, 0, 6909, 6907, 1,
		0, 0, 0, 6909, 6908, 1, 0, 0, 0, 6909, 6910, 1, 0, 0, 0, 6910, 6911, 1,
		0, 0, 0, 6911, 6914, 5, 68, 0, 0, 6912, 6915, 3, 594, 297, 0, 6913, 6915,
		3, 688, 344, 0, 6914, 6912, 1, 0, 0, 0, 6914, 6913, 1, 0, 0, 0, 6915, 6916,
		1, 0, 0, 0, 6916, 6917, 5, 1134, 0, 0, 6917, 6985, 1, 0, 0, 0, 6918, 6919,
		5, 328, 0, 0, 6919, 6922, 5, 1133, 0, 0, 6920, 6923, 3, 594, 297, 0, 6921,
		6923, 3, 688, 344, 0, 6922, 6920, 1, 0, 0, 0, 6922, 6921, 1, 0, 0, 0, 6923,
		6924, 1, 0, 0, 0, 6924, 6927, 5, 68, 0, 0, 6925, 6928, 3, 594, 297, 0,
		6926, 6928, 3, 688, 344, 0, 6927, 6925, 1, 0, 0, 0, 6927, 6926, 1, 0, 0,
		0, 6928, 6929, 1, 0, 0, 0, 6929, 6930, 5, 1134, 0, 0, 6930, 6985, 1, 0,
		0, 0, 6931, 6932, 5, 1103, 0, 0, 6932, 6935, 5, 1133, 0, 0, 6933, 6936,
		3, 594, 297, 0, 6934, 6936, 3, 688, 344, 0, 6935, 6933, 1, 0, 0, 0, 6935,
		6934, 1, 0, 0, 0, 6936, 6943, 1, 0, 0, 0, 6937, 6938, 5, 12, 0, 0, 6938,
		6939, 7, 119, 0, 0, 6939, 6940, 5, 1133, 0, 0, 6940, 6941, 3, 590, 295,
		0, 6941, 6942, 5, 1134, 0, 0, 6942, 6944, 1, 0, 0, 0, 6943, 6937, 1, 0,
		0, 0, 6943, 6944, 1, 0, 0, 0, 6944, 6946, 1, 0, 0, 0, 6945, 6947, 3, 654,
		327, 0, 6946, 6945, 1, 0, 0, 0, 6946, 6947, 1, 0, 0, 0, 6947, 6948, 1,
		0, 0, 0, 6948, 6949, 5, 1134, 0, 0, 6949, 6985, 1, 0, 0, 0, 6950, 6951,
		5, 321, 0, 0, 6951, 6952, 5, 1133, 0, 0, 6952, 6953, 3, 72, 36, 0, 6953,
		6956, 5, 68, 0, 0, 6954, 6957, 3, 594, 297, 0, 6955, 6957, 3, 688, 344,
		0, 6956, 6954, 1, 0, 0, 0, 6956, 6955, 1, 0, 0, 0, 6957, 6958, 1, 0, 0,
		0, 6958, 6959, 5, 1134, 0, 0, 6959, 6985, 1, 0, 0, 0, 6960, 6961, 5, 900,
		0, 0, 6961, 6962, 5, 1133, 0, 0, 6962, 6963, 7, 120, 0, 0, 6963, 6964,
		5, 1135, 0, 0, 6964, 6965, 3, 594, 297, 0, 6965, 6966, 5, 1134, 0, 0, 6966,
		6985, 1, 0, 0, 0, 6967, 6968, 5, 282, 0, 0, 6968, 6969, 5, 1133, 0, 0,
		6969, 6970, 3, 688, 344, 0, 6970, 6971, 5, 1135, 0, 0, 6971, 6974, 3, 688,
		344, 0, 6972, 6973, 5, 593, 0, 0, 6973, 6975, 3, 608, 304, 0, 6974, 6972,
		1, 0, 0, 0, 6974, 6975, 1, 0, 0, 0, 6975, 6977, 1, 0, 0, 0, 6976, 6978,
		3, 268, 134, 0, 6977, 6976, 1, 0, 0, 0, 6977, 6978, 1, 0, 0, 0, 6978, 6980,
		1, 0, 0, 0, 6979, 6981, 3, 270, 135, 0, 6980, 6979, 1, 0, 0, 0, 6980, 6981,
		1, 0, 0, 0, 6981, 6982, 1, 0, 0, 0, 6982, 6983, 5, 1134, 0, 0, 6983, 6985,
		1, 0, 0, 0, 6984, 6805, 1, 0, 0, 0, 6984, 6810, 1, 0, 0, 0, 6984, 6811,
		1, 0, 0, 0, 6984, 6818, 1, 0, 0, 0, 6984, 6825, 1, 0, 0, 0, 6984, 6832,
		1, 0, 0, 0, 6984, 6837, 1, 0, 0, 0, 6984, 6850, 1, 0, 0, 0, 6984, 6862,
		1, 0, 0, 0, 6984, 6871, 1, 0, 0, 0, 6984, 6884, 1, 0, 0, 0, 6984, 6904,
		1, 0, 0, 0, 6984, 6918, 1, 0, 0, 0, 6984, 6931, 1, 0, 0, 0, 6984, 6950,
		1, 0, 0, 0, 6984, 6960, 1, 0, 0, 0, 6984, 6967, 1, 0, 0, 0, 6985, 651,
		1, 0, 0, 0, 6986, 6987, 5, 189, 0, 0, 6987, 6988, 3, 686, 343, 0, 6988,
		6989, 5, 174, 0, 0, 6989, 6990, 3, 686, 343, 0, 6990, 653, 1, 0, 0, 0,
		6991, 6992, 5, 472, 0, 0, 6992, 6997, 3, 656, 328, 0, 6993, 6994, 5, 1135,
		0, 0, 6994, 6996, 3, 656, 328, 0, 6995, 6993, 1, 0, 0, 0, 6996, 6999, 1,
		0, 0, 0, 6997, 6995, 1, 0, 0, 0, 6997, 6998, 1, 0, 0, 0, 6998, 7006, 1,
		0, 0, 0, 6999, 6997, 1, 0, 0, 0, 7000, 7001, 5, 472, 0, 0, 7001, 7002,
		3, 590, 295, 0, 7002, 7003, 5, 1121, 0, 0, 7003, 7004, 3, 590, 295, 0,
		7004, 7006, 1, 0, 0, 0, 7005, 6991, 1, 0, 0, 0, 7005, 7000, 1, 0, 0, 0,
		7006, 655, 1, 0, 0, 0, 7007, 7009, 3, 590, 295, 0, 7008, 7010, 7, 121,
		0, 0, 7009, 7008, 1, 0, 0, 0, 7009, 7010, 1, 0, 0, 0, 7010, 657, 1, 0,
		0, 0, 7011, 7012, 7, 122, 0, 0, 7012, 7014, 5, 1133, 0, 0, 7013, 7015,
		7, 44, 0, 0, 7014, 7013, 1, 0, 0, 0, 7014, 7015, 1, 0, 0, 0, 7015, 7016,
		1, 0, 0, 0, 7016, 7017, 3, 686, 343, 0, 7017, 7019, 5, 1134, 0, 0, 7018,
		7020, 3, 662, 331, 0, 7019, 7018, 1, 0, 0, 0, 7019, 7020, 1, 0, 0, 0, 7020,
		7071, 1, 0, 0, 0, 7021, 7022, 5, 290, 0, 0, 7022, 7030, 5, 1133, 0, 0,
		7023, 7031, 5, 1117, 0, 0, 7024, 7026, 5, 6, 0, 0, 7025, 7024, 1, 0, 0,
		0, 7025, 7026, 1, 0, 0, 0, 7026, 7027, 1, 0, 0, 0, 7027, 7031, 3, 686,
		343, 0, 7028, 7029, 5, 49, 0, 0, 7029, 7031, 3, 684, 342, 0, 7030, 7023,
		1, 0, 0, 0, 7030, 7025, 1, 0, 0, 0, 7030, 7028, 1, 0, 0, 0, 7031, 7032,
		1, 0, 0, 0, 7032, 7034, 5, 1134, 0, 0, 7033, 7035, 3, 662, 331, 0, 7034,
		7033, 1, 0, 0, 0, 7034, 7035, 1, 0, 0, 0, 7035, 7071, 1, 0, 0, 0, 7036,
		7037, 7, 123, 0, 0, 7037, 7039, 5, 1133, 0, 0, 7038, 7040, 5, 6, 0, 0,
		7039, 7038, 1, 0, 0, 0, 7039, 7040, 1, 0, 0, 0, 7040, 7041, 1, 0, 0, 0,
		7041, 7042, 3, 686, 343, 0, 7042, 7044, 5, 1134, 0, 0, 7043, 7045, 3, 662,
		331, 0, 7044, 7043, 1, 0, 0, 0, 7044, 7045, 1, 0, 0, 0, 7045, 7071, 1,
		0, 0, 0, 7046, 7047, 5, 294, 0, 0, 7047, 7049, 5, 1133, 0, 0, 7048, 7050,
		5, 49, 0, 0, 7049, 7048, 1, 0, 0, 0, 7049, 7050, 1, 0, 0, 0, 7050, 7051,
		1, 0, 0, 0, 7051, 7062, 3, 684, 342, 0, 7052, 7053, 5, 124, 0, 0, 7053,
		7054, 5, 19, 0, 0, 7054, 7059, 3, 232, 116, 0, 7055, 7056, 5, 1135, 0,
		0, 7056, 7058, 3, 232, 116, 0, 7057, 7055, 1, 0, 0, 0, 7058, 7061, 1, 0,
		0, 0, 7059, 7057, 1, 0, 0, 0, 7059, 7060, 1, 0, 0, 0, 7060, 7063, 1, 0,
		0, 0, 7061, 7059, 1, 0, 0, 0, 7062, 7052, 1, 0, 0, 0, 7062, 7063, 1, 0,
		0, 0, 7063, 7066, 1, 0, 0, 0, 7064, 7065, 5, 154, 0, 0, 7065, 7067, 5,
		1148, 0, 0, 7066, 7064, 1, 0, 0, 0, 7066, 7067, 1, 0, 0, 0, 7067, 7068,
		1, 0, 0, 0, 7068, 7069, 5, 1134, 0, 0, 7069, 7071, 1, 0, 0, 0, 7070, 7011,
		1, 0, 0, 0, 7070, 7021, 1, 0, 0, 0, 7070, 7036, 1, 0, 0, 0, 7070, 7046,
		1, 0, 0, 0, 7071, 659, 1, 0, 0, 0, 7072, 7073, 7, 124, 0, 0, 7073, 7074,
		5, 1133, 0, 0, 7074, 7077, 3, 688, 344, 0, 7075, 7076, 5, 1135, 0, 0, 7076,
		7078, 3, 590, 295, 0, 7077, 7075, 1, 0, 0, 0, 7077, 7078, 1, 0, 0, 0, 7078,
		7081, 1, 0, 0, 0, 7079, 7080, 5, 1135, 0, 0, 7080, 7082, 3, 590, 295, 0,
		7081, 7079, 1, 0, 0, 0, 7081, 7082, 1, 0, 0, 0, 7082, 7083, 1, 0, 0, 0,
		7083, 7084, 5, 1134, 0, 0, 7084, 7085, 3, 662, 331, 0, 7085, 7111, 1, 0,
		0, 0, 7086, 7087, 7, 125, 0, 0, 7087, 7088, 5, 1133, 0, 0, 7088, 7089,
		3, 688, 344, 0, 7089, 7090, 5, 1134, 0, 0, 7090, 7091, 3, 662, 331, 0,
		7091, 7111, 1, 0, 0, 0, 7092, 7093, 7, 126, 0, 0, 7093, 7094, 5, 1133,
		0, 0, 7094, 7095, 5, 1134, 0, 0, 7095, 7111, 3, 662, 331, 0, 7096, 7097,
		5, 301, 0, 0, 7097, 7098, 5, 1133, 0, 0, 7098, 7099, 3, 688, 344, 0, 7099,
		7100, 5, 1135, 0, 0, 7100, 7101, 3, 590, 295, 0, 7101, 7102, 5, 1134, 0,
		0, 7102, 7103, 3, 662, 331, 0, 7103, 7111, 1, 0, 0, 0, 7104, 7105, 5, 300,
		0, 0, 7105, 7106, 5, 1133, 0, 0, 7106, 7107, 3, 590, 295, 0, 7107, 7108,
		5, 1134, 0, 0, 7108, 7109, 3, 662, 331, 0, 7109, 7111, 1, 0, 0, 0, 7110,
		7072, 1, 0, 0, 0, 7110, 7086, 1, 0, 0, 0, 7110, 7092, 1, 0, 0, 0, 7110,
		7096, 1, 0, 0, 0, 7110, 7104, 1, 0, 0, 0, 7111, 661, 1, 0, 0, 0, 7112,
		7118, 5, 128, 0, 0, 7113, 7114, 5, 1133, 0, 0, 7114, 7115, 3, 664, 332,
		0, 7115, 7116, 5, 1134, 0, 0, 7116, 7119, 1, 0, 0, 0, 7117, 7119, 3, 666,
		333, 0, 7118, 7113, 1, 0, 0, 0, 7118, 7117, 1, 0, 0, 0, 7119, 663, 1, 0,
		0, 0, 7120, 7122, 3, 666, 333, 0, 7121, 7120, 1, 0, 0, 0, 7121, 7122, 1,
		0, 0, 0, 7122, 7124, 1, 0, 0, 0, 7123, 7125, 3, 678, 339, 0, 7124, 7123,
		1, 0, 0, 0, 7124, 7125, 1, 0, 0, 0, 7125, 7127, 1, 0, 0, 0, 7126, 7128,
		3, 230, 115, 0, 7127, 7126, 1, 0, 0, 0, 7127, 7128, 1, 0, 0, 0, 7128, 7130,
		1, 0, 0, 0, 7129, 7131, 3, 668, 334, 0, 7130, 7129, 1, 0, 0, 0, 7130, 7131,
		1, 0, 0, 0, 7131, 665, 1, 0, 0, 0, 7132, 7133, 3, 584, 292, 0, 7133, 667,
		1, 0, 0, 0, 7134, 7135, 3, 670, 335, 0, 7135, 7136, 3, 672, 336, 0, 7136,
		669, 1, 0, 0, 0, 7137, 7138, 7, 127, 0, 0, 7138, 671, 1, 0, 0, 0, 7139,
		7142, 3, 676, 338, 0, 7140, 7142, 3, 674, 337, 0, 7141, 7139, 1, 0, 0,
		0, 7141, 7140, 1, 0, 0, 0, 7142, 673, 1, 0, 0, 0, 7143, 7144, 5, 16, 0,
		0, 7144, 7145, 3, 676, 338, 0, 7145, 7146, 5, 10, 0, 0, 7146, 7147, 3,
		676, 338, 0, 7147, 675, 1, 0, 0, 0, 7148, 7149, 5, 35, 0, 0, 7149, 7156,
		5, 600, 0, 0, 7150, 7151, 5, 657, 0, 0, 7151, 7156, 7, 128, 0, 0, 7152,
		7153, 3, 688, 344, 0, 7153, 7154, 7, 128, 0, 0, 7154, 7156, 1, 0, 0, 0,
		7155, 7148, 1, 0, 0, 0, 7155, 7150, 1, 0, 0, 0, 7155, 7152, 1, 0, 0, 0,
		7156, 677, 1, 0, 0, 0, 7157, 7158, 5, 129, 0, 0, 7158, 7159, 5, 19, 0,
		0, 7159, 7164, 3, 688, 344, 0, 7160, 7161, 5, 1135, 0, 0, 7161, 7163, 3,
		688, 344, 0, 7162, 7160, 1, 0, 0, 0, 7163, 7166, 1, 0, 0, 0, 7164, 7162,
		1, 0, 0, 0, 7164, 7165, 1, 0, 0, 0, 7165, 679, 1, 0, 0, 0, 7166, 7164,
		1, 0, 0, 0, 7167, 7192, 3, 720, 360, 0, 7168, 7192, 5, 747, 0, 0, 7169,
		7192, 5, 317, 0, 0, 7170, 7192, 5, 313, 0, 0, 7171, 7192, 5, 314, 0, 0,
		7172, 7192, 5, 315, 0, 0, 7173, 7192, 5, 318, 0, 0, 7174, 7192, 5, 319,
		0, 0, 7175, 7192, 5, 320, 0, 0, 7176, 7192, 5, 77, 0, 0, 7177, 7192, 5,
		85, 0, 0, 7178, 7192, 5, 316, 0, 0, 7179, 7192, 5, 322, 0, 0, 7180, 7192,
		5, 508, 0, 0, 7181, 7192, 5, 323, 0, 0, 7182, 7192, 5, 140, 0, 0, 7183,
		7192, 5, 141, 0, 0, 7184, 7192, 5, 325, 0, 0, 7185, 7192, 5, 326, 0, 0,
		7186, 7192, 5, 327, 0, 0, 7187, 7192, 5, 328, 0, 0, 7188, 7192, 5, 329,
		0, 0, 7189, 7192, 5, 330, 0, 0, 7190, 7192, 5, 331, 0, 0, 7191, 7167, 1,
		0, 0, 0, 7191, 7168, 1, 0, 0, 0, 7191, 7169, 1, 0, 0, 0, 7191, 7170, 1,
		0, 0, 0, 7191, 7171, 1, 0, 0, 0, 7191, 7172, 1, 0, 0, 0, 7191, 7173, 1,
		0, 0, 0, 7191, 7174, 1, 0, 0, 0, 7191, 7175, 1, 0, 0, 0, 7191, 7176, 1,
		0, 0, 0, 7191, 7177, 1, 0, 0, 0, 7191, 7178, 1, 0, 0, 0, 7191, 7179, 1,
		0, 0, 0, 7191, 7180, 1, 0, 0, 0, 7191, 7181, 1, 0, 0, 0, 7191, 7182, 1,
		0, 0, 0, 7191, 7183, 1, 0, 0, 0, 7191, 7184, 1, 0, 0, 0, 7191, 7185, 1,
		0, 0, 0, 7191, 7186, 1, 0, 0, 0, 7191, 7187, 1, 0, 0, 0, 7191, 7188, 1,
		0, 0, 0, 7191, 7189, 1, 0, 0, 0, 7191, 7190, 1, 0, 0, 0, 7192, 681, 1,
		0, 0, 0, 7193, 7194, 7, 129, 0, 0, 7194, 7195, 5, 1133, 0, 0, 7195, 7196,
		3, 686, 343, 0, 7196, 7197, 5, 1134, 0, 0, 7197, 683, 1, 0, 0, 0, 7198,
		7203, 3, 602, 301, 0, 7199, 7203, 3, 556, 278, 0, 7200, 7203, 3, 648, 324,
		0, 7201, 7203, 3, 688, 344, 0, 7202, 7198, 1, 0, 0, 0, 7202, 7199, 1, 0,
		0, 0, 7202, 7200, 1, 0, 0, 0, 7202, 7201, 1, 0, 0, 0, 7203, 7213, 1, 0,
		0, 0, 7204, 7209, 5, 1135, 0, 0, 7205, 7210, 3, 602, 301, 0, 7206, 7210,
		3, 556, 278, 0, 7207, 7210, 3, 648, 324, 0, 7208, 7210, 3, 688, 344, 0,
		7209, 7205, 1, 0, 0, 0, 7209, 7206, 1, 0, 0, 0, 7209, 7207, 1, 0, 0, 0,
		7209, 7208, 1, 0, 0, 0, 7210, 7212, 1, 0, 0, 0, 7211, 7204, 1, 0, 0, 0,
		7212, 7215, 1, 0, 0, 0, 7213, 7211, 1, 0, 0, 0, 7213, 7214, 1, 0, 0, 0,
		7214, 685, 1, 0, 0, 0, 7215, 7213, 1, 0, 0, 0, 7216, 7221, 3, 602, 301,
		0, 7217, 7221, 3, 556, 278, 0, 7218, 7221, 3, 648, 324, 0, 7219, 7221,
		3, 688, 344, 0, 7220, 7216, 1, 0, 0, 0, 7220, 7217, 1, 0, 0, 0, 7220, 7218,
		1, 0, 0, 0, 7220, 7219, 1, 0, 0, 0, 7221, 687, 1, 0, 0, 0, 7222, 7223,
		6, 344, -1, 0, 7223, 7224, 7, 130, 0, 0, 7224, 7234, 3, 688, 344, 4, 7225,
		7226, 3, 690, 345, 0, 7226, 7228, 5, 88, 0, 0, 7227, 7229, 5, 114, 0, 0,
		7228, 7227, 1, 0, 0, 0, 7228, 7229, 1, 0, 0, 0, 7229, 7230, 1, 0, 0, 0,
		7230, 7231, 7, 131, 0, 0, 7231, 7234, 1, 0, 0, 0, 7232, 7234, 3, 690, 345,
		0, 7233, 7222, 1, 0, 0, 0, 7233, 7225, 1, 0, 0, 0, 7233, 7232, 1, 0, 0,
		0, 7234, 7241, 1, 0, 0, 0, 7235, 7236, 10, 3, 0, 0, 7236, 7237, 3, 698,
		349, 0, 7237, 7238, 3, 688, 344, 4, 7238, 7240, 1, 0, 0, 0, 7239, 7235,
		1, 0, 0, 0, 7240, 7243, 1, 0, 0, 0, 7241, 7239, 1, 0, 0, 0, 7241, 7242,
		1, 0, 0, 0, 7242, 689, 1, 0, 0, 0, 7243, 7241, 1, 0, 0, 0, 7244, 7245,
		6, 345, -1, 0, 7245, 7246, 3, 692, 346, 0, 7246, 7311, 1, 0, 0, 0, 7247,
		7248, 10, 8, 0, 0, 7248, 7249, 3, 696, 348, 0, 7249, 7250, 3, 690, 345,
		9, 7250, 7310, 1, 0, 0, 0, 7251, 7253, 10, 6, 0, 0, 7252, 7254, 5, 114,
		0, 0, 7253, 7252, 1, 0, 0, 0, 7253, 7254, 1, 0, 0, 0, 7254, 7255, 1, 0,
		0, 0, 7255, 7256, 5, 16, 0, 0, 7256, 7257, 3, 690, 345, 0, 7257, 7258,
		5, 10, 0, 0, 7258, 7259, 3, 690, 345, 7, 7259, 7310, 1, 0, 0, 0, 7260,
		7261, 10, 5, 0, 0, 7261, 7262, 5, 620, 0, 0, 7262, 7263, 5, 98, 0, 0, 7263,
		7310, 3, 690, 345, 6, 7264, 7266, 10, 3, 0, 0, 7265, 7267, 5, 114, 0, 0,
		7266, 7265, 1, 0, 0, 0, 7266, 7267, 1, 0, 0, 0, 7267, 7268, 1, 0, 0, 0,
		7268, 7269, 7, 132, 0, 0, 7269, 7310, 3, 690, 345, 4, 7270, 7272, 10, 10,
		0, 0, 7271, 7273, 5, 114, 0, 0, 7272, 7271, 1, 0, 0, 0, 7272, 7273, 1,
		0, 0, 0, 7273, 7274, 1, 0, 0, 0, 7274, 7275, 5, 80, 0, 0, 7275, 7278, 5,
		1133, 0, 0, 7276, 7279, 3, 200, 100, 0, 7277, 7279, 3, 624, 312, 0, 7278,
		7276, 1, 0, 0, 0, 7278, 7277, 1, 0, 0, 0, 7279, 7280, 1, 0, 0, 0, 7280,
		7281, 5, 1134, 0, 0, 7281, 7310, 1, 0, 0, 0, 7282, 7283, 10, 9, 0, 0, 7283,
		7284, 5, 88, 0, 0, 7284, 7310, 3, 600, 300, 0, 7285, 7286, 10, 7, 0, 0,
		7286, 7287, 3, 696, 348, 0, 7287, 7288, 7, 133, 0, 0, 7288, 7289, 5, 1133,
		0, 0, 7289, 7290, 3, 200, 100, 0, 7290, 7291, 5, 1134, 0, 0, 7291, 7310,
		1, 0, 0, 0, 7292, 7294, 10, 4, 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,
		5, 98, 0, 0, 7297, 7300, 3, 690, 345, 0, 7298, 7299, 5, 413, 0, 0, 7299,
		7301, 5, 1148, 0, 0, 7300, 7298, 1, 0, 0, 0, 7300, 7301, 1, 0, 0, 0, 7301,
		7310, 1, 0, 0, 0, 7302, 7303, 10, 2, 0, 0, 7303, 7304, 5, 505, 0, 0, 7304,
		7305, 5, 533, 0, 0, 7305, 7306, 5, 1133, 0, 0, 7306, 7307, 3, 690, 345,
		0, 7307, 7308, 5, 1134, 0, 0, 7308, 7310, 1, 0, 0, 0, 7309, 7247, 1, 0,
		0, 0, 7309, 7251, 1, 0, 0, 0, 7309, 7260, 1, 0, 0, 0, 7309, 7264, 1, 0,
		0, 0, 7309, 7270, 1, 0, 0, 0, 7309, 7282, 1, 0, 0, 0, 7309, 7285, 1, 0,
		0, 0, 7309, 7292, 1, 0, 0, 0, 7309, 7302, 1, 0, 0, 0, 7310, 7313, 1, 0,
		0, 0, 7311, 7309, 1, 0, 0, 0, 7311, 7312, 1, 0, 0, 0, 7312, 691, 1, 0,
		0, 0, 7313, 7311, 1, 0, 0, 0, 7314, 7315, 6, 346, -1, 0, 7315, 7363, 3,
		602, 301, 0, 7316, 7363, 3, 556, 278, 0, 7317, 7363, 3, 648, 324, 0, 7318,
		7363, 3, 566, 283, 0, 7319, 7320, 3, 694, 347, 0, 7320, 7321, 3, 692, 346,
		12, 7321, 7363, 1, 0, 0, 0, 7322, 7323, 5, 226, 0, 0, 7323, 7363, 3, 692,
		346, 11, 7324, 7325, 5, 1159, 0, 0, 7325, 7326, 5, 1108, 0, 0, 7326, 7363,
		3, 692, 346, 10, 7327, 7328, 5, 1133, 0, 0, 7328, 7333, 3, 688, 344, 0,
		7329, 7330, 5, 1135, 0, 0, 7330, 7332, 3, 688, 344, 0, 7331, 7329, 1, 0,
		0, 0, 7332, 7335, 1, 0, 0, 0, 7333, 7331, 1, 0, 0, 0, 7333, 7334, 1, 0,
		0, 0, 7334, 7336, 1, 0, 0, 0, 7335, 7333, 1, 0, 0, 0, 7336, 7337, 5, 1134,
		0, 0, 7337, 7363, 1, 0, 0, 0, 7338, 7339, 5, 600, 0, 0, 7339, 7340, 5,
		1133, 0, 0, 7340, 7343, 3, 688, 344, 0, 7341, 7342, 5, 1135, 0, 0, 7342,
		7344, 3, 688, 344, 0, 7343, 7341, 1, 0, 0, 0, 7344, 7345, 1, 0, 0, 0, 7345,
		7343, 1, 0, 0, 0, 7345, 7346, 1, 0, 0, 0, 7346, 7347, 1, 0, 0, 0, 7347,
		7348, 5, 1134, 0, 0, 7348, 7363, 1, 0, 0, 0, 7349, 7350, 5, 60, 0, 0, 7350,
		7351, 5, 1133, 0, 0, 7351, 7352, 3, 200, 100, 0, 7352, 7353, 5, 1134, 0,
		0, 7353, 7363, 1, 0, 0, 0, 7354, 7355, 5, 1133, 0, 0, 7355, 7356, 3, 200,
		100, 0, 7356, 7357, 5, 1134, 0, 0, 7357, 7363, 1, 0, 0, 0, 7358, 7359,
		5, 86, 0, 0, 7359, 7360, 3, 688, 344, 0, 7360, 7361, 3, 72, 36, 0, 7361,
		7363, 1, 0, 0, 0, 7362, 7314, 1, 0, 0, 0, 7362, 7316, 1, 0, 0, 0, 7362,
		7317, 1, 0, 0, 0, 7362, 7318, 1, 0, 0, 0, 7362, 7319, 1, 0, 0, 0, 7362,
		7322, 1, 0, 0, 0, 7362, 7324, 1, 0, 0, 0, 7362, 7327, 1, 0, 0, 0, 7362,
		7338, 1, 0, 0, 0, 7362, 7349, 1, 0, 0, 0, 7362, 7354, 1, 0, 0, 0, 7362,
		7358, 1, 0, 0, 0, 7363, 7385, 1, 0, 0, 0, 7364, 7365, 10, 4, 0, 0, 7365,
		7366, 3, 700, 350, 0, 7366, 7367, 3, 692, 346, 5, 7367, 7384, 1, 0, 0,
		0, 7368, 7369, 10, 3, 0, 0, 7369, 7370, 3, 702, 351, 0, 7370, 7371, 3,
		692, 346, 4, 7371, 7384, 1, 0, 0, 0, 7372, 7373, 10, 2, 0, 0, 7373, 7374,
		3, 704, 352, 0, 7374, 7375, 3, 692, 346, 3, 7375, 7384, 1, 0, 0, 0, 7376,
		7377, 10, 1, 0, 0, 7377, 7378, 3, 706, 353, 0, 7378, 7379, 3, 692, 346,
		2, 7379, 7384, 1, 0, 0, 0, 7380, 7381, 10, 14, 0, 0, 7381, 7382, 5, 27,
		0, 0, 7382, 7384, 3, 570, 285, 0, 7383, 7364, 1, 0, 0, 0, 7383, 7368, 1,
		0, 0, 0, 7383, 7372, 1, 0, 0, 0, 7383, 7376, 1, 0, 0, 0, 7383, 7380, 1,
		0, 0, 0, 7384, 7387, 1, 0, 0, 0, 7385, 7383, 1, 0, 0, 0, 7385, 7386, 1,
		0, 0, 0, 7386, 693, 1, 0, 0, 0, 7387, 7385, 1, 0, 0, 0, 7388, 7389, 7,
		134, 0, 0, 7389, 695, 1, 0, 0, 0, 7390, 7405, 5, 1124, 0, 0, 7391, 7405,
		5, 1125, 0, 0, 7392, 7405, 5, 1126, 0, 0, 7393, 7394, 5, 1126, 0, 0, 7394,
		7405, 5, 1124, 0, 0, 7395, 7396, 5, 1125, 0, 0, 7396, 7405, 5, 1124, 0,
		0, 7397, 7398, 5, 1126, 0, 0, 7398, 7405, 5, 1125, 0, 0, 7399, 7400, 5,
		1127, 0, 0, 7400, 7405, 5, 1124, 0, 0, 7401, 7402, 5, 1126, 0, 0, 7402,
		7403, 5, 1124, 0, 0, 7403, 7405, 5, 1125, 0, 0, 7404, 7390, 1, 0, 0, 0,
		7404, 7391, 1, 0, 0, 0, 7404, 7392, 1, 0, 0, 0, 7404, 7393, 1, 0, 0, 0,
		7404, 7395, 1, 0, 0, 0, 7404, 7397, 1, 0, 0, 0, 7404, 7399, 1, 0, 0, 0,
		7404, 7401, 1, 0, 0, 0, 7405, 697, 1, 0, 0, 0, 7406, 7414, 5, 10, 0, 0,
		7407, 7408, 5, 1130, 0, 0, 7408, 7414, 5, 1130, 0, 0, 7409, 7414, 5, 194,
		0, 0, 7410, 7414, 5, 123, 0, 0, 7411, 7412, 5, 1129, 0, 0, 7412, 7414,
		5, 1129, 0, 0, 7413, 7406, 1, 0, 0, 0, 7413, 7407, 1, 0, 0, 0, 7413, 7409,
		1, 0, 0, 0, 7413, 7410, 1, 0, 0, 0, 7413, 7411, 1, 0, 0, 0, 7414, 699,
		1, 0, 0, 0, 7415, 7416, 5, 1126, 0, 0, 7416, 7423, 5, 1126, 0, 0, 7417,
		7418, 5, 1125, 0, 0, 7418, 7423, 5, 1125, 0, 0, 7419, 7423, 5, 1130, 0,
		0, 7420, 7423, 5, 1131, 0, 0, 7421, 7423, 5, 1129, 0, 0, 7422, 7415, 1,
		0, 0, 0, 7422, 7417, 1, 0, 0, 0, 7422, 7419, 1, 0, 0, 0, 7422, 7420, 1,
		0, 0, 0, 7422, 7421, 1, 0, 0, 0, 7423, 701, 1, 0, 0, 0, 7424, 7425, 7,
		135, 0, 0, 7425, 703, 1, 0, 0, 0, 7426, 7427, 7, 136, 0, 0, 7427, 705,
		1, 0, 0, 0, 7428, 7429, 5, 1121, 0, 0, 7429, 7434, 5, 1125, 0, 0, 7430,
		7431, 5, 1121, 0, 0, 7431, 7432, 5, 1125, 0, 0, 7432, 7434, 5, 1125, 0,
		0, 7433, 7428, 1, 0, 0, 0, 7433, 7430, 1, 0, 0, 0, 7434, 707, 1, 0, 0,
		0, 7435, 7436, 7, 137, 0, 0, 7436, 709, 1, 0, 0, 0, 7437, 7438, 7, 138,
		0, 0, 7438, 711, 1, 0, 0, 0, 7439, 7440, 7, 139, 0, 0, 7440, 713, 1, 0,
		0, 0, 7441, 7442, 7, 140, 0, 0, 7442, 715, 1, 0, 0, 0, 7443, 7444, 7, 141,
		0, 0, 7444, 717, 1, 0, 0, 0, 7445, 7446, 7, 142, 0, 0, 7446, 719, 1, 0,
		0, 0, 7447, 7448, 7, 143, 0, 0, 7448, 721, 1, 0, 0, 0, 1087, 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,
		5265, 5270, 5279, 5285, 5296, 5302, 5307, 5311, 5317, 5322, 5326, 5329,
		5341, 5348, 5353, 5383, 5387, 5392, 5399, 5402, 5408, 5418, 5428, 5438,
		5444, 5453, 5459, 5466, 5468, 5478, 5482, 5486, 5496, 5501, 5573, 5591,
		5599, 5611, 5618, 5620, 5630, 5633, 5641, 5648, 5652, 5659, 5664, 5667,
		5670, 5679, 5683, 5687, 5710, 5717, 5721, 5728, 5735, 5738, 5754, 5757,
		5767, 5771, 5777, 5780, 5785, 5789, 5796, 5799, 5805, 5829, 5832, 5844,
		5847, 5857, 5865, 5869, 5876, 5879, 5888, 5894, 5900, 5910, 5912, 5918,
		5921, 5924, 5936, 5939, 5945, 5948, 5956, 5964, 5970, 5974, 5988, 6000,
		6007, 6010, 6017, 6024, 6029, 6042, 6053, 6059, 6064, 6077, 6079, 6084,
		6088, 6091, 6093, 6100, 6107, 6110, 6113, 6119, 6123, 6129, 6135, 6148,
		6153, 6161, 6164, 6169, 6174, 6182, 6185, 6193, 6197, 6204, 6210, 6213,
		6217, 6230, 6236, 6248, 6251, 6260, 6265, 6271, 6277, 6282, 6284, 6287,
		6291, 6293, 6297, 6303, 6306, 6309, 6315, 6324, 6332, 6336, 6341, 6361,
		6368, 6370, 6377, 6379, 6383, 6388, 6399, 6404, 6410, 6413, 6417, 6422,
		6425, 6429, 6433, 6435, 6440, 6445, 6458, 6461, 6465, 6468, 6471, 6476,
		6481, 6487, 6490, 6495, 6498, 6503, 6506, 6510, 6515, 6520, 6525, 6530,
		6533, 6538, 6543, 6548, 6554, 6559, 6564, 6569, 6573, 6576, 6581, 6585,
		6589, 6597, 6604, 6608, 6613, 6618, 6622, 6624, 6627, 6643, 6652, 6660,
		6668, 6677, 6687, 6695, 6703, 6711, 6719, 6731, 6738, 6748, 6753, 6756,
		6761, 6764, 6768, 6783, 6791, 6798, 6803, 6808, 6842, 6846, 6854, 6858,
		6867, 6875, 6880, 6888, 6893, 6898, 6900, 6909, 6914, 6922, 6927, 6935,
		6943, 6946, 6956, 6974, 6977, 6980, 6984, 6997, 7005, 7009, 7014, 7019,
		7025, 7030, 7034, 7039, 7044, 7049, 7059, 7062, 7066, 7070, 7077, 7081,
		7110, 7118, 7121, 7124, 7127, 7130, 7141, 7155, 7164, 7191, 7202, 7209,
		7213, 7220, 7228, 7233, 7241, 7253, 7266, 7272, 7278, 7294, 7300, 7309,
		7311, 7333, 7345, 7362, 7383, 7385, 7404, 7413, 7422, 7433,
	}
	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
	MySqlParserYEAR_MONTH                        = 240
	MySqlParserDAY_HOUR                          = 241
	MySqlParserDAY_MINUTE                        = 242
	MySqlParserDAY_SECOND                        = 243
	MySqlParserHOUR_MINUTE                       = 244
	MySqlParserHOUR_SECOND                       = 245
	MySqlParserMINUTE_SECOND                     = 246
	MySqlParserSECOND_MICROSECOND                = 247
	MySqlParserMINUTE_MICROSECOND                = 248
	MySqlParserHOUR_MICROSECOND                  = 249
	MySqlParserDAY_MICROSECOND                   = 250
	MySqlParserJSON_ARRAY                        = 251
	MySqlParserJSON_ARRAYAGG                     = 252
	MySqlParserJSON_ARRAY_APPEND                 = 253
	MySqlParserJSON_ARRAY_INSERT                 = 254
	MySqlParserJSON_CONTAINS                     = 255
	MySqlParserJSON_CONTAINS_PATH                = 256
	MySqlParserJSON_DEPTH                        = 257
	MySqlParserJSON_EXTRACT                      = 258
	MySqlParserJSON_INSERT                       = 259
	MySqlParserJSON_KEYS                         = 260
	MySqlParserJSON_LENGTH                       = 261
	MySqlParserJSON_MERGE                        = 262
	MySqlParserJSON_MERGE_PATCH                  = 263
	MySqlParserJSON_MERGE_PRESERVE               = 264
	MySqlParserJSON_OBJECT                       = 265
	MySqlParserJSON_OBJECTAGG                    = 266
	MySqlParserJSON_OVERLAPS                     = 267
	MySqlParserJSON_PRETTY                       = 268
	MySqlParserJSON_QUOTE                        = 269
	MySqlParserJSON_REMOVE                       = 270
	MySqlParserJSON_REPLACE                      = 271
	MySqlParserJSON_SCHEMA_VALID                 = 272
	MySqlParserJSON_SCHEMA_VALIDATION_REPORT     = 273
	MySqlParserJSON_SEARCH                       = 274
	MySqlParserJSON_SET                          = 275
	MySqlParserJSON_STORAGE_FREE                 = 276
	MySqlParserJSON_STORAGE_SIZE                 = 277
	MySqlParserJSON_TABLE                        = 278
	MySqlParserJSON_TYPE                         = 279
	MySqlParserJSON_UNQUOTE                      = 280
	MySqlParserJSON_VALID                        = 281
	MySqlParserJSON_VALUE                        = 282
	MySqlParserNESTED                            = 283
	MySqlParserORDINALITY                        = 284
	MySqlParserPATH                              = 285
	MySqlParserAVG                               = 286
	MySqlParserBIT_AND                           = 287
	MySqlParserBIT_OR                            = 288
	MySqlParserBIT_XOR                           = 289
	MySqlParserCOUNT                             = 290
	MySqlParserCUME_DIST                         = 291
	MySqlParserDENSE_RANK                        = 292
	MySqlParserFIRST_VALUE                       = 293
	MySqlParserGROUP_CONCAT                      = 294
	MySqlParserLAG                               = 295
	MySqlParserLAST_VALUE                        = 296
	MySqlParserLEAD                              = 297
	MySqlParserMAX                               = 298
	MySqlParserMIN                               = 299
	MySqlParserNTILE                             = 300
	MySqlParserNTH_VALUE                         = 301
	MySqlParserPERCENT_RANK                      = 302
	MySqlParserRANK                              = 303
	MySqlParserROW_NUMBER                        = 304
	MySqlParserSTD                               = 305
	MySqlParserSTDDEV                            = 306
	MySqlParserSTDDEV_POP                        = 307
	MySqlParserSTDDEV_SAMP                       = 308
	MySqlParserSUM                               = 309
	MySqlParserVAR_POP                           = 310
	MySqlParserVAR_SAMP                          = 311
	MySqlParserVARIANCE                          = 312
	MySqlParserCURRENT_DATE                      = 313
	MySqlParserCURRENT_TIME                      = 314
	MySqlParserCURRENT_TIMESTAMP                 = 315
	MySqlParserLOCALTIME                         = 316
	MySqlParserCURDATE                           = 317
	MySqlParserCURTIME                           = 318
	MySqlParserDATE_ADD                          = 319
	MySqlParserDATE_SUB                          = 320
	MySqlParserEXTRACT                           = 321
	MySqlParserLOCALTIMESTAMP                    = 322
	MySqlParserNOW                               = 323
	MySqlParserPOSITION                          = 324
	MySqlParserSUBSTR                            = 325
	MySqlParserSUBSTRING                         = 326
	MySqlParserSYSDATE                           = 327
	MySqlParserTRIM                              = 328
	MySqlParserUTC_DATE                          = 329
	MySqlParserUTC_TIME                          = 330
	MySqlParserUTC_TIMESTAMP                     = 331
	MySqlParserACCOUNT                           = 332
	MySqlParserACTION                            = 333
	MySqlParserAFTER                             = 334
	MySqlParserAGGREGATE                         = 335
	MySqlParserALGORITHM                         = 336
	MySqlParserANY                               = 337
	MySqlParserAT                                = 338
	MySqlParserAUTHORS                           = 339
	MySqlParserAUTOCOMMIT                        = 340
	MySqlParserAUTOEXTEND_SIZE                   = 341
	MySqlParserAUTO_INCREMENT                    = 342
	MySqlParserAVG_ROW_LENGTH                    = 343
	MySqlParserBEGIN                             = 344
	MySqlParserBINLOG                            = 345
	MySqlParserBIT                               = 346
	MySqlParserBLOCK                             = 347
	MySqlParserBOOL                              = 348
	MySqlParserBOOLEAN                           = 349
	MySqlParserBTREE                             = 350
	MySqlParserCACHE                             = 351
	MySqlParserCASCADED                          = 352
	MySqlParserCHAIN                             = 353
	MySqlParserCHANGED                           = 354
	MySqlParserCHANNEL                           = 355
	MySqlParserCHECKSUM                          = 356
	MySqlParserPAGE_CHECKSUM                     = 357
	MySqlParserCIPHER                            = 358
	MySqlParserCLASS_ORIGIN                      = 359
	MySqlParserCLIENT                            = 360
	MySqlParserCLOSE                             = 361
	MySqlParserCLUSTERING                        = 362
	MySqlParserCOALESCE                          = 363
	MySqlParserCODE                              = 364
	MySqlParserCOLUMNS                           = 365
	MySqlParserCOLUMN_FORMAT                     = 366
	MySqlParserCOLUMN_NAME                       = 367
	MySqlParserCOMMENT                           = 368
	MySqlParserCOMMIT                            = 369
	MySqlParserCOMPACT                           = 370
	MySqlParserCOMPLETION                        = 371
	MySqlParserCOMPRESSED                        = 372
	MySqlParserCOMPRESSION                       = 373
	MySqlParserCONCURRENT                        = 374
	MySqlParserCONNECT                           = 375
	MySqlParserCONNECTION                        = 376
	MySqlParserCONSISTENT                        = 377
	MySqlParserCONSTRAINT_CATALOG                = 378
	MySqlParserCONSTRAINT_SCHEMA                 = 379
	MySqlParserCONSTRAINT_NAME                   = 380
	MySqlParserCONTAINS                          = 381
	MySqlParserCONTEXT                           = 382
	MySqlParserCONTRIBUTORS                      = 383
	MySqlParserCOPY                              = 384
	MySqlParserCPU                               = 385
	MySqlParserCYCLE                             = 386
	MySqlParserCURSOR_NAME                       = 387
	MySqlParserDATA                              = 388
	MySqlParserDATAFILE                          = 389
	MySqlParserDEALLOCATE                        = 390
	MySqlParserDEFAULT_AUTH                      = 391
	MySqlParserDEFINER                           = 392
	MySqlParserDELAY_KEY_WRITE                   = 393
	MySqlParserDES_KEY_FILE                      = 394
	MySqlParserDIRECTORY                         = 395
	MySqlParserDISABLE                           = 396
	MySqlParserDISCARD                           = 397
	MySqlParserDISK                              = 398
	MySqlParserDO                                = 399
	MySqlParserDUMPFILE                          = 400
	MySqlParserDUPLICATE                         = 401
	MySqlParserDYNAMIC                           = 402
	MySqlParserENABLE                            = 403
	MySqlParserENCRYPTED                         = 404
	MySqlParserENCRYPTION                        = 405
	MySqlParserENCRYPTION_KEY_ID                 = 406
	MySqlParserEND                               = 407
	MySqlParserENDS                              = 408
	MySqlParserENGINE                            = 409
	MySqlParserENGINES                           = 410
	MySqlParserERROR                             = 411
	MySqlParserERRORS                            = 412
	MySqlParserESCAPE                            = 413
	MySqlParserEVEN                              = 414
	MySqlParserEVENT                             = 415
	MySqlParserEVENTS                            = 416
	MySqlParserEVERY                             = 417
	MySqlParserEXCHANGE                          = 418
	MySqlParserEXCLUSIVE                         = 419
	MySqlParserEXPIRE                            = 420
	MySqlParserEXPORT                            = 421
	MySqlParserEXTENDED                          = 422
	MySqlParserEXTENT_SIZE                       = 423
	MySqlParserFAILED_LOGIN_ATTEMPTS             = 424
	MySqlParserFAST                              = 425
	MySqlParserFAULTS                            = 426
	MySqlParserFIELDS                            = 427
	MySqlParserFILE_BLOCK_SIZE                   = 428
	MySqlParserFILTER                            = 429
	MySqlParserFIRST                             = 430
	MySqlParserFIXED                             = 431
	MySqlParserFLUSH                             = 432
	MySqlParserFOLLOWING                         = 433
	MySqlParserFOLLOWS                           = 434
	MySqlParserFOUND                             = 435
	MySqlParserFULL                              = 436
	MySqlParserFUNCTION                          = 437
	MySqlParserGENERAL                           = 438
	MySqlParserGLOBAL                            = 439
	MySqlParserGRANTS                            = 440
	MySqlParserGROUP_REPLICATION                 = 441
	MySqlParserHANDLER                           = 442
	MySqlParserHASH                              = 443
	MySqlParserHELP                              = 444
	MySqlParserHISTORY                           = 445
	MySqlParserHOST                              = 446
	MySqlParserHOSTS                             = 447
	MySqlParserIDENTIFIED                        = 448
	MySqlParserIGNORE_SERVER_IDS                 = 449
	MySqlParserIMPORT                            = 450
	MySqlParserINCREMENT                         = 451
	MySqlParserINDEXES                           = 452
	MySqlParserINITIAL_SIZE                      = 453
	MySqlParserINPLACE                           = 454
	MySqlParserINSERT_METHOD                     = 455
	MySqlParserINSTALL                           = 456
	MySqlParserINSTANCE                          = 457
	MySqlParserINSTANT                           = 458
	MySqlParserINVISIBLE                         = 459
	MySqlParserINVOKER                           = 460
	MySqlParserIO                                = 461
	MySqlParserIO_THREAD                         = 462
	MySqlParserIPC                               = 463
	MySqlParserISOLATION                         = 464
	MySqlParserISSUER                            = 465
	MySqlParserJSON                              = 466
	MySqlParserKEY_BLOCK_SIZE                    = 467
	MySqlParserLANGUAGE                          = 468
	MySqlParserLAST                              = 469
	MySqlParserLEAVES                            = 470
	MySqlParserLESS                              = 471
	MySqlParserLEVEL                             = 472
	MySqlParserLIST                              = 473
	MySqlParserLOCAL                             = 474
	MySqlParserLOGFILE                           = 475
	MySqlParserLOGS                              = 476
	MySqlParserMASTER                            = 477
	MySqlParserMASTER_AUTO_POSITION              = 478
	MySqlParserMASTER_CONNECT_RETRY              = 479
	MySqlParserMASTER_DELAY                      = 480
	MySqlParserMASTER_HEARTBEAT_PERIOD           = 481
	MySqlParserMASTER_HOST                       = 482
	MySqlParserMASTER_LOG_FILE                   = 483
	MySqlParserMASTER_LOG_POS                    = 484
	MySqlParserMASTER_PASSWORD                   = 485
	MySqlParserMASTER_PORT                       = 486
	MySqlParserMASTER_RETRY_COUNT                = 487
	MySqlParserMASTER_SSL                        = 488
	MySqlParserMASTER_SSL_CA                     = 489
	MySqlParserMASTER_SSL_CAPATH                 = 490
	MySqlParserMASTER_SSL_CERT                   = 491
	MySqlParserMASTER_SSL_CIPHER                 = 492
	MySqlParserMASTER_SSL_CRL                    = 493
	MySqlParserMASTER_SSL_CRLPATH                = 494
	MySqlParserMASTER_SSL_KEY                    = 495
	MySqlParserMASTER_TLS_VERSION                = 496
	MySqlParserMASTER_USER                       = 497
	MySqlParserMAX_CONNECTIONS_PER_HOUR          = 498
	MySqlParserMAX_QUERIES_PER_HOUR              = 499
	MySqlParserMAX_ROWS                          = 500
	MySqlParserMAX_SIZE                          = 501
	MySqlParserMAX_UPDATES_PER_HOUR              = 502
	MySqlParserMAX_USER_CONNECTIONS              = 503
	MySqlParserMEDIUM                            = 504
	MySqlParserMEMBER                            = 505
	MySqlParserMERGE                             = 506
	MySqlParserMESSAGE_TEXT                      = 507
	MySqlParserMID                               = 508
	MySqlParserMIGRATE                           = 509
	MySqlParserMIN_ROWS                          = 510
	MySqlParserMODE                              = 511
	MySqlParserMODIFY                            = 512
	MySqlParserMUTEX                             = 513
	MySqlParserMYSQL                             = 514
	MySqlParserMYSQL_ERRNO                       = 515
	MySqlParserNAME                              = 516
	MySqlParserNAMES                             = 517
	MySqlParserNCHAR                             = 518
	MySqlParserNEVER                             = 519
	MySqlParserNEXT                              = 520
	MySqlParserNO                                = 521
	MySqlParserNOCACHE                           = 522
	MySqlParserNOCOPY                            = 523
	MySqlParserNOCYCLE                           = 524
	MySqlParserNOMAXVALUE                        = 525
	MySqlParserNOMINVALUE                        = 526
	MySqlParserNOWAIT                            = 527
	MySqlParserNODEGROUP                         = 528
	MySqlParserNONE                              = 529
	MySqlParserODBC                              = 530
	MySqlParserOFFLINE                           = 531
	MySqlParserOFFSET                            = 532
	MySqlParserOF                                = 533
	MySqlParserOJ                                = 534
	MySqlParserOLD_PASSWORD                      = 535
	MySqlParserONE                               = 536
	MySqlParserONLINE                            = 537
	MySqlParserONLY                              = 538
	MySqlParserOPEN                              = 539
	MySqlParserOPTIMIZER_COSTS                   = 540
	MySqlParserOPTIONS                           = 541
	MySqlParserOWNER                             = 542
	MySqlParserPACK_KEYS                         = 543
	MySqlParserPAGE                              = 544
	MySqlParserPAGE_COMPRESSED                   = 545
	MySqlParserPAGE_COMPRESSION_LEVEL            = 546
	MySqlParserPARSER                            = 547
	MySqlParserPARTIAL                           = 548
	MySqlParserPARTITIONING                      = 549
	MySqlParserPARTITIONS                        = 550
	MySqlParserPASSWORD                          = 551
	MySqlParserPASSWORD_LOCK_TIME                = 552
	MySqlParserPHASE                             = 553
	MySqlParserPLUGIN                            = 554
	MySqlParserPLUGIN_DIR                        = 555
	MySqlParserPLUGINS                           = 556
	MySqlParserPORT                              = 557
	MySqlParserPRECEDES                          = 558
	MySqlParserPRECEDING                         = 559
	MySqlParserPREPARE                           = 560
	MySqlParserPRESERVE                          = 561
	MySqlParserPREV                              = 562
	MySqlParserPROCESSLIST                       = 563
	MySqlParserPROFILE                           = 564
	MySqlParserPROFILES                          = 565
	MySqlParserPROXY                             = 566
	MySqlParserQUERY                             = 567
	MySqlParserQUICK                             = 568
	MySqlParserREBUILD                           = 569
	MySqlParserRECOVER                           = 570
	MySqlParserRECURSIVE                         = 571
	MySqlParserREDO_BUFFER_SIZE                  = 572
	MySqlParserREDUNDANT                         = 573
	MySqlParserRELAY                             = 574
	MySqlParserRELAY_LOG_FILE                    = 575
	MySqlParserRELAY_LOG_POS                     = 576
	MySqlParserRELAYLOG                          = 577
	MySqlParserREMOVE                            = 578
	MySqlParserREORGANIZE                        = 579
	MySqlParserREPAIR                            = 580
	MySqlParserREPLICATE_DO_DB                   = 581
	MySqlParserREPLICATE_DO_TABLE                = 582
	MySqlParserREPLICATE_IGNORE_DB               = 583
	MySqlParserREPLICATE_IGNORE_TABLE            = 584
	MySqlParserREPLICATE_REWRITE_DB              = 585
	MySqlParserREPLICATE_WILD_DO_TABLE           = 586
	MySqlParserREPLICATE_WILD_IGNORE_TABLE       = 587
	MySqlParserREPLICATION                       = 588
	MySqlParserRESET                             = 589
	MySqlParserRESTART                           = 590
	MySqlParserRESUME                            = 591
	MySqlParserRETURNED_SQLSTATE                 = 592
	MySqlParserRETURNING                         = 593
	MySqlParserRETURNS                           = 594
	MySqlParserREUSE                             = 595
	MySqlParserROLE                              = 596
	MySqlParserROLLBACK                          = 597
	MySqlParserROLLUP                            = 598
	MySqlParserROTATE                            = 599
	MySqlParserROW                               = 600
	MySqlParserROWS                              = 601
	MySqlParserROW_FORMAT                        = 602
	MySqlParserRTREE                             = 603
	MySqlParserSAVEPOINT                         = 604
	MySqlParserSCHEDULE                          = 605
	MySqlParserSECURITY                          = 606
	MySqlParserSEQUENCE                          = 607
	MySqlParserSERVER                            = 608
	MySqlParserSESSION                           = 609
	MySqlParserSHARE                             = 610
	MySqlParserSHARED                            = 611
	MySqlParserSIGNED                            = 612
	MySqlParserSIMPLE                            = 613
	MySqlParserSLAVE                             = 614
	MySqlParserSLOW                              = 615
	MySqlParserSNAPSHOT                          = 616
	MySqlParserSOCKET                            = 617
	MySqlParserSOME                              = 618
	MySqlParserSONAME                            = 619
	MySqlParserSOUNDS                            = 620
	MySqlParserSOURCE                            = 621
	MySqlParserSQL_AFTER_GTIDS                   = 622
	MySqlParserSQL_AFTER_MTS_GAPS                = 623
	MySqlParserSQL_BEFORE_GTIDS                  = 624
	MySqlParserSQL_BUFFER_RESULT                 = 625
	MySqlParserSQL_CACHE                         = 626
	MySqlParserSQL_NO_CACHE                      = 627
	MySqlParserSQL_THREAD                        = 628
	MySqlParserSTART                             = 629
	MySqlParserSTARTS                            = 630
	MySqlParserSTATS_AUTO_RECALC                 = 631
	MySqlParserSTATS_PERSISTENT                  = 632
	MySqlParserSTATS_SAMPLE_PAGES                = 633
	MySqlParserSTATUS                            = 634
	MySqlParserSTOP                              = 635
	MySqlParserSTORAGE                           = 636
	MySqlParserSTORED                            = 637
	MySqlParserSTRING                            = 638
	MySqlParserSUBCLASS_ORIGIN                   = 639
	MySqlParserSUBJECT                           = 640
	MySqlParserSUBPARTITION                      = 641
	MySqlParserSUBPARTITIONS                     = 642
	MySqlParserSUSPEND                           = 643
	MySqlParserSWAPS                             = 644
	MySqlParserSWITCHES                          = 645
	MySqlParserTABLE_NAME                        = 646
	MySqlParserTABLESPACE                        = 647
	MySqlParserTABLE_TYPE                        = 648
	MySqlParserTEMPORARY                         = 649
	MySqlParserTEMPTABLE                         = 650
	MySqlParserTHAN                              = 651
	MySqlParserTRADITIONAL                       = 652
	MySqlParserTRANSACTION                       = 653
	MySqlParserTRANSACTIONAL                     = 654
	MySqlParserTRIGGERS                          = 655
	MySqlParserTRUNCATE                          = 656
	MySqlParserUNBOUNDED                         = 657
	MySqlParserUNDEFINED                         = 658
	MySqlParserUNDOFILE                          = 659
	MySqlParserUNDO_BUFFER_SIZE                  = 660
	MySqlParserUNINSTALL                         = 661
	MySqlParserUNKNOWN                           = 662
	MySqlParserUNTIL                             = 663
	MySqlParserUPGRADE                           = 664
	MySqlParserUSER                              = 665
	MySqlParserUSE_FRM                           = 666
	MySqlParserUSER_RESOURCES                    = 667
	MySqlParserVALIDATION                        = 668
	MySqlParserVALUE                             = 669
	MySqlParserVARIABLES                         = 670
	MySqlParserVIEW                              = 671
	MySqlParserVIRTUAL                           = 672
	MySqlParserVISIBLE                           = 673
	MySqlParserWAIT                              = 674
	MySqlParserWARNINGS                          = 675
	MySqlParserWINDOW                            = 676
	MySqlParserWITHOUT                           = 677
	MySqlParserWORK                              = 678
	MySqlParserWRAPPER                           = 679
	MySqlParserX509                              = 680
	MySqlParserXA                                = 681
	MySqlParserXML                               = 682
	MySqlParserYES                               = 683
	MySqlParserEUR                               = 684
	MySqlParserUSA                               = 685
	MySqlParserJIS                               = 686
	MySqlParserISO                               = 687
	MySqlParserINTERNAL                          = 688
	MySqlParserQUARTER                           = 689
	MySqlParserMONTH                             = 690
	MySqlParserDAY                               = 691
	MySqlParserHOUR                              = 692
	MySqlParserMINUTE                            = 693
	MySqlParserWEEK                              = 694
	MySqlParserSECOND                            = 695
	MySqlParserMICROSECOND                       = 696
	MySqlParserADMIN                             = 697
	MySqlParserAPPLICATION_PASSWORD_ADMIN        = 698
	MySqlParserAUDIT_ABORT_EXEMPT                = 699
	MySqlParserAUDIT_ADMIN                       = 700
	MySqlParserAUTHENTICATION_POLICY_ADMIN       = 701
	MySqlParserBACKUP_ADMIN                      = 702
	MySqlParserBINLOG_ADMIN                      = 703
	MySqlParserBINLOG_ENCRYPTION_ADMIN           = 704
	MySqlParserCLONE_ADMIN                       = 705
	MySqlParserCONNECTION_ADMIN                  = 706
	MySqlParserENCRYPTION_KEY_ADMIN              = 707
	MySqlParserEXECUTE                           = 708
	MySqlParserFILE                              = 709
	MySqlParserFIREWALL_ADMIN                    = 710
	MySqlParserFIREWALL_EXEMPT                   = 711
	MySqlParserFIREWALL_USER                     = 712
	MySqlParserFLUSH_OPTIMIZER_COSTS             = 713
	MySqlParserFLUSH_STATUS                      = 714
	MySqlParserFLUSH_TABLES                      = 715
	MySqlParserFLUSH_USER_RESOURCES              = 716
	MySqlParserGROUP_REPLICATION_ADMIN           = 717
	MySqlParserINNODB_REDO_LOG_ARCHIVE           = 718
	MySqlParserINNODB_REDO_LOG_ENABLE            = 719
	MySqlParserINVOKE                            = 720
	MySqlParserLAMBDA                            = 721
	MySqlParserNDB_STORED_USER                   = 722
	MySqlParserPASSWORDLESS_USER_ADMIN           = 723
	MySqlParserPERSIST_RO_VARIABLES_ADMIN        = 724
	MySqlParserPRIVILEGES                        = 725
	MySqlParserPROCESS                           = 726
	MySqlParserRELOAD                            = 727
	MySqlParserREPLICATION_APPLIER               = 728
	MySqlParserREPLICATION_SLAVE_ADMIN           = 729
	MySqlParserRESOURCE_GROUP_ADMIN              = 730
	MySqlParserRESOURCE_GROUP_USER               = 731
	MySqlParserROLE_ADMIN                        = 732
	MySqlParserROUTINE                           = 733
	MySqlParserS3                                = 734
	MySqlParserSERVICE_CONNECTION_ADMIN          = 735
	MySqlParserSESSION_VARIABLES_ADMIN           = 736
	MySqlParserSET_USER_ID                       = 737
	MySqlParserSHOW_ROUTINE                      = 738
	MySqlParserSHUTDOWN                          = 739
	MySqlParserSUPER                             = 740
	MySqlParserSYSTEM_VARIABLES_ADMIN            = 741
	MySqlParserTABLES                            = 742
	MySqlParserTABLE_ENCRYPTION_ADMIN            = 743
	MySqlParserVERSION_TOKEN_ADMIN               = 744
	MySqlParserXA_RECOVER_ADMIN                  = 745
	MySqlParserARMSCII8                          = 746
	MySqlParserASCII                             = 747
	MySqlParserBIG5                              = 748
	MySqlParserCP1250                            = 749
	MySqlParserCP1251                            = 750
	MySqlParserCP1256                            = 751
	MySqlParserCP1257                            = 752
	MySqlParserCP850                             = 753
	MySqlParserCP852                             = 754
	MySqlParserCP866                             = 755
	MySqlParserCP932                             = 756
	MySqlParserDEC8                              = 757
	MySqlParserEUCJPMS                           = 758
	MySqlParserEUCKR                             = 759
	MySqlParserGB18030                           = 760
	MySqlParserGB2312                            = 761
	MySqlParserGBK                               = 762
	MySqlParserGEOSTD8                           = 763
	MySqlParserGREEK                             = 764
	MySqlParserHEBREW                            = 765
	MySqlParserHP8                               = 766
	MySqlParserKEYBCS2                           = 767
	MySqlParserKOI8R                             = 768
	MySqlParserKOI8U                             = 769
	MySqlParserLATIN1                            = 770
	MySqlParserLATIN2                            = 771
	MySqlParserLATIN5                            = 772
	MySqlParserLATIN7                            = 773
	MySqlParserMACCE                             = 774
	MySqlParserMACROMAN                          = 775
	MySqlParserSJIS                              = 776
	MySqlParserSWE7                              = 777
	MySqlParserTIS620                            = 778
	MySqlParserUCS2                              = 779
	MySqlParserUJIS                              = 780
	MySqlParserUTF16                             = 781
	MySqlParserUTF16LE                           = 782
	MySqlParserUTF32                             = 783
	MySqlParserUTF8                              = 784
	MySqlParserUTF8MB3                           = 785
	MySqlParserUTF8MB4                           = 786
	MySqlParserARCHIVE                           = 787
	MySqlParserBLACKHOLE                         = 788
	MySqlParserCSV                               = 789
	MySqlParserFEDERATED                         = 790
	MySqlParserINNODB                            = 791
	MySqlParserMEMORY                            = 792
	MySqlParserMRG_MYISAM                        = 793
	MySqlParserMYISAM                            = 794
	MySqlParserNDB                               = 795
	MySqlParserNDBCLUSTER                        = 796
	MySqlParserPERFORMANCE_SCHEMA                = 797
	MySqlParserTOKUDB                            = 798
	MySqlParserREPEATABLE                        = 799
	MySqlParserCOMMITTED                         = 800
	MySqlParserUNCOMMITTED                       = 801
	MySqlParserSERIALIZABLE                      = 802
	MySqlParserGEOMETRYCOLLECTION                = 803
	MySqlParserGEOMCOLLECTION                    = 804
	MySqlParserGEOMETRY                          = 805
	MySqlParserLINESTRING                        = 806
	MySqlParserMULTILINESTRING                   = 807
	MySqlParserMULTIPOINT                        = 808
	MySqlParserMULTIPOLYGON                      = 809
	MySqlParserPOINT                             = 810
	MySqlParserPOLYGON                           = 811
	MySqlParserABS                               = 812
	MySqlParserACOS                              = 813
	MySqlParserADDDATE                           = 814
	MySqlParserADDTIME                           = 815
	MySqlParserAES_DECRYPT                       = 816
	MySqlParserAES_ENCRYPT                       = 817
	MySqlParserAREA                              = 818
	MySqlParserASBINARY                          = 819
	MySqlParserASIN                              = 820
	MySqlParserASTEXT                            = 821
	MySqlParserASWKB                             = 822
	MySqlParserASWKT                             = 823
	MySqlParserASYMMETRIC_DECRYPT                = 824
	MySqlParserASYMMETRIC_DERIVE                 = 825
	MySqlParserASYMMETRIC_ENCRYPT                = 826
	MySqlParserASYMMETRIC_SIGN                   = 827
	MySqlParserASYMMETRIC_VERIFY                 = 828
	MySqlParserATAN                              = 829
	MySqlParserATAN2                             = 830
	MySqlParserBENCHMARK                         = 831
	MySqlParserBIN                               = 832
	MySqlParserBIT_COUNT                         = 833
	MySqlParserBIT_LENGTH                        = 834
	MySqlParserBUFFER                            = 835
	MySqlParserCATALOG_NAME                      = 836
	MySqlParserCEIL                              = 837
	MySqlParserCEILING                           = 838
	MySqlParserCENTROID                          = 839
	MySqlParserCHARACTER_LENGTH                  = 840
	MySqlParserCHARSET                           = 841
	MySqlParserCHAR_LENGTH                       = 842
	MySqlParserCOERCIBILITY                      = 843
	MySqlParserCOLLATION                         = 844
	MySqlParserCOMPRESS                          = 845
	MySqlParserCONCAT                            = 846
	MySqlParserCONCAT_WS                         = 847
	MySqlParserCONNECTION_ID                     = 848
	MySqlParserCONV                              = 849
	MySqlParserCONVERT_TZ                        = 850
	MySqlParserCOS                               = 851
	MySqlParserCOT                               = 852
	MySqlParserCRC32                             = 853
	MySqlParserCREATE_ASYMMETRIC_PRIV_KEY        = 854
	MySqlParserCREATE_ASYMMETRIC_PUB_KEY         = 855
	MySqlParserCREATE_DH_PARAMETERS              = 856
	MySqlParserCREATE_DIGEST                     = 857
	MySqlParserCROSSES                           = 858
	MySqlParserDATEDIFF                          = 859
	MySqlParserDATE_FORMAT                       = 860
	MySqlParserDAYNAME                           = 861
	MySqlParserDAYOFMONTH                        = 862
	MySqlParserDAYOFWEEK                         = 863
	MySqlParserDAYOFYEAR                         = 864
	MySqlParserDECODE                            = 865
	MySqlParserDEGREES                           = 866
	MySqlParserDES_DECRYPT                       = 867
	MySqlParserDES_ENCRYPT                       = 868
	MySqlParserDIMENSION                         = 869
	MySqlParserDISJOINT                          = 870
	MySqlParserELT                               = 871
	MySqlParserENCODE                            = 872
	MySqlParserENCRYPT                           = 873
	MySqlParserENDPOINT                          = 874
	MySqlParserENGINE_ATTRIBUTE                  = 875
	MySqlParserENVELOPE                          = 876
	MySqlParserEQUALS                            = 877
	MySqlParserEXP                               = 878
	MySqlParserEXPORT_SET                        = 879
	MySqlParserEXTERIORRING                      = 880
	MySqlParserEXTRACTVALUE                      = 881
	MySqlParserFIELD                             = 882
	MySqlParserFIND_IN_SET                       = 883
	MySqlParserFLOOR                             = 884
	MySqlParserFORMAT                            = 885
	MySqlParserFOUND_ROWS                        = 886
	MySqlParserFROM_BASE64                       = 887
	MySqlParserFROM_DAYS                         = 888
	MySqlParserFROM_UNIXTIME                     = 889
	MySqlParserGEOMCOLLFROMTEXT                  = 890
	MySqlParserGEOMCOLLFROMWKB                   = 891
	MySqlParserGEOMETRYCOLLECTIONFROMTEXT        = 892
	MySqlParserGEOMETRYCOLLECTIONFROMWKB         = 893
	MySqlParserGEOMETRYFROMTEXT                  = 894
	MySqlParserGEOMETRYFROMWKB                   = 895
	MySqlParserGEOMETRYN                         = 896
	MySqlParserGEOMETRYTYPE                      = 897
	MySqlParserGEOMFROMTEXT                      = 898
	MySqlParserGEOMFROMWKB                       = 899
	MySqlParserGET_FORMAT                        = 900
	MySqlParserGET_LOCK                          = 901
	MySqlParserGLENGTH                           = 902
	MySqlParserGREATEST                          = 903
	MySqlParserGTID_SUBSET                       = 904
	MySqlParserGTID_SUBTRACT                     = 905
	MySqlParserHEX                               = 906
	MySqlParserIFNULL                            = 907
	MySqlParserINET6_ATON                        = 908
	MySqlParserINET6_NTOA                        = 909
	MySqlParserINET_ATON                         = 910
	MySqlParserINET_NTOA                         = 911
	MySqlParserINSTR                             = 912
	MySqlParserINTERIORRINGN                     = 913
	MySqlParserINTERSECTS                        = 914
	MySqlParserISCLOSED                          = 915
	MySqlParserISEMPTY                           = 916
	MySqlParserISNULL                            = 917
	MySqlParserISSIMPLE                          = 918
	MySqlParserIS_FREE_LOCK                      = 919
	MySqlParserIS_IPV4                           = 920
	MySqlParserIS_IPV4_COMPAT                    = 921
	MySqlParserIS_IPV4_MAPPED                    = 922
	MySqlParserIS_IPV6                           = 923
	MySqlParserIS_USED_LOCK                      = 924
	MySqlParserLAST_INSERT_ID                    = 925
	MySqlParserLCASE                             = 926
	MySqlParserLEAST                             = 927
	MySqlParserLENGTH                            = 928
	MySqlParserLINEFROMTEXT                      = 929
	MySqlParserLINEFROMWKB                       = 930
	MySqlParserLINESTRINGFROMTEXT                = 931
	MySqlParserLINESTRINGFROMWKB                 = 932
	MySqlParserLN                                = 933
	MySqlParserLOAD_FILE                         = 934
	MySqlParserLOCATE                            = 935
	MySqlParserLOG                               = 936
	MySqlParserLOG10                             = 937
	MySqlParserLOG2                              = 938
	MySqlParserLOWER                             = 939
	MySqlParserLPAD                              = 940
	MySqlParserLTRIM                             = 941
	MySqlParserMAKEDATE                          = 942
	MySqlParserMAKETIME                          = 943
	MySqlParserMAKE_SET                          = 944
	MySqlParserMASTER_POS_WAIT                   = 945
	MySqlParserMBRCONTAINS                       = 946
	MySqlParserMBRDISJOINT                       = 947
	MySqlParserMBREQUAL                          = 948
	MySqlParserMBRINTERSECTS                     = 949
	MySqlParserMBROVERLAPS                       = 950
	MySqlParserMBRTOUCHES                        = 951
	MySqlParserMBRWITHIN                         = 952
	MySqlParserMD5                               = 953
	MySqlParserMLINEFROMTEXT                     = 954
	MySqlParserMLINEFROMWKB                      = 955
	MySqlParserMONTHNAME                         = 956
	MySqlParserMPOINTFROMTEXT                    = 957
	MySqlParserMPOINTFROMWKB                     = 958
	MySqlParserMPOLYFROMTEXT                     = 959
	MySqlParserMPOLYFROMWKB                      = 960
	MySqlParserMULTILINESTRINGFROMTEXT           = 961
	MySqlParserMULTILINESTRINGFROMWKB            = 962
	MySqlParserMULTIPOINTFROMTEXT                = 963
	MySqlParserMULTIPOINTFROMWKB                 = 964
	MySqlParserMULTIPOLYGONFROMTEXT              = 965
	MySqlParserMULTIPOLYGONFROMWKB               = 966
	MySqlParserNAME_CONST                        = 967
	MySqlParserNULLIF                            = 968
	MySqlParserNUMGEOMETRIES                     = 969
	MySqlParserNUMINTERIORRINGS                  = 970
	MySqlParserNUMPOINTS                         = 971
	MySqlParserOCT                               = 972
	MySqlParserOCTET_LENGTH                      = 973
	MySqlParserORD                               = 974
	MySqlParserOVERLAPS                          = 975
	MySqlParserPERIOD_ADD                        = 976
	MySqlParserPERIOD_DIFF                       = 977
	MySqlParserPI                                = 978
	MySqlParserPOINTFROMTEXT                     = 979
	MySqlParserPOINTFROMWKB                      = 980
	MySqlParserPOINTN                            = 981
	MySqlParserPOLYFROMTEXT                      = 982
	MySqlParserPOLYFROMWKB                       = 983
	MySqlParserPOLYGONFROMTEXT                   = 984
	MySqlParserPOLYGONFROMWKB                    = 985
	MySqlParserPOW                               = 986
	MySqlParserPOWER                             = 987
	MySqlParserQUOTE                             = 988
	MySqlParserRADIANS                           = 989
	MySqlParserRAND                              = 990
	MySqlParserRANDOM                            = 991
	MySqlParserRANDOM_BYTES                      = 992
	MySqlParserRELEASE_LOCK                      = 993
	MySqlParserREVERSE                           = 994
	MySqlParserROUND                             = 995
	MySqlParserROW_COUNT                         = 996
	MySqlParserRPAD                              = 997
	MySqlParserRTRIM                             = 998
	MySqlParserSEC_TO_TIME                       = 999
	MySqlParserSECONDARY_ENGINE_ATTRIBUTE        = 1000
	MySqlParserSESSION_USER                      = 1001
	MySqlParserSHA                               = 1002
	MySqlParserSHA1                              = 1003
	MySqlParserSHA2                              = 1004
	MySqlParserSCHEMA_NAME                       = 1005
	MySqlParserSIGN                              = 1006
	MySqlParserSIN                               = 1007
	MySqlParserSLEEP                             = 1008
	MySqlParserSOUNDEX                           = 1009
	MySqlParserSQL_THREAD_WAIT_AFTER_GTIDS       = 1010
	MySqlParserSQRT                              = 1011
	MySqlParserSRID                              = 1012
	MySqlParserSTARTPOINT                        = 1013
	MySqlParserSTRCMP                            = 1014
	MySqlParserSTR_TO_DATE                       = 1015
	MySqlParserST_AREA                           = 1016
	MySqlParserST_ASBINARY                       = 1017
	MySqlParserST_ASTEXT                         = 1018
	MySqlParserST_ASWKB                          = 1019
	MySqlParserST_ASWKT                          = 1020
	MySqlParserST_BUFFER                         = 1021
	MySqlParserST_CENTROID                       = 1022
	MySqlParserST_CONTAINS                       = 1023
	MySqlParserST_CROSSES                        = 1024
	MySqlParserST_DIFFERENCE                     = 1025
	MySqlParserST_DIMENSION                      = 1026
	MySqlParserST_DISJOINT                       = 1027
	MySqlParserST_DISTANCE                       = 1028
	MySqlParserST_ENDPOINT                       = 1029
	MySqlParserST_ENVELOPE                       = 1030
	MySqlParserST_EQUALS                         = 1031
	MySqlParserST_EXTERIORRING                   = 1032
	MySqlParserST_GEOMCOLLFROMTEXT               = 1033
	MySqlParserST_GEOMCOLLFROMTXT                = 1034
	MySqlParserST_GEOMCOLLFROMWKB                = 1035
	MySqlParserST_GEOMETRYCOLLECTIONFROMTEXT     = 1036
	MySqlParserST_GEOMETRYCOLLECTIONFROMWKB      = 1037
	MySqlParserST_GEOMETRYFROMTEXT               = 1038
	MySqlParserST_GEOMETRYFROMWKB                = 1039
	MySqlParserST_GEOMETRYN                      = 1040
	MySqlParserST_GEOMETRYTYPE                   = 1041
	MySqlParserST_GEOMFROMTEXT                   = 1042
	MySqlParserST_GEOMFROMWKB                    = 1043
	MySqlParserST_INTERIORRINGN                  = 1044
	MySqlParserST_INTERSECTION                   = 1045
	MySqlParserST_INTERSECTS                     = 1046
	MySqlParserST_ISCLOSED                       = 1047
	MySqlParserST_ISEMPTY                        = 1048
	MySqlParserST_ISSIMPLE                       = 1049
	MySqlParserST_LINEFROMTEXT                   = 1050
	MySqlParserST_LINEFROMWKB                    = 1051
	MySqlParserST_LINESTRINGFROMTEXT             = 1052
	MySqlParserST_LINESTRINGFROMWKB              = 1053
	MySqlParserST_NUMGEOMETRIES                  = 1054
	MySqlParserST_NUMINTERIORRING                = 1055
	MySqlParserST_NUMINTERIORRINGS               = 1056
	MySqlParserST_NUMPOINTS                      = 1057
	MySqlParserST_OVERLAPS                       = 1058
	MySqlParserST_POINTFROMTEXT                  = 1059
	MySqlParserST_POINTFROMWKB                   = 1060
	MySqlParserST_POINTN                         = 1061
	MySqlParserST_POLYFROMTEXT                   = 1062
	MySqlParserST_POLYFROMWKB                    = 1063
	MySqlParserST_POLYGONFROMTEXT                = 1064
	MySqlParserST_POLYGONFROMWKB                 = 1065
	MySqlParserST_SRID                           = 1066
	MySqlParserST_STARTPOINT                     = 1067
	MySqlParserST_SYMDIFFERENCE                  = 1068
	MySqlParserST_TOUCHES                        = 1069
	MySqlParserST_UNION                          = 1070
	MySqlParserST_WITHIN                         = 1071
	MySqlParserST_X                              = 1072
	MySqlParserST_Y                              = 1073
	MySqlParserSUBDATE                           = 1074
	MySqlParserSUBSTRING_INDEX                   = 1075
	MySqlParserSUBTIME                           = 1076
	MySqlParserSYSTEM_USER                       = 1077
	MySqlParserTAN                               = 1078
	MySqlParserTIMEDIFF                          = 1079
	MySqlParserTIMESTAMPADD                      = 1080
	MySqlParserTIMESTAMPDIFF                     = 1081
	MySqlParserTIME_FORMAT                       = 1082
	MySqlParserTIME_TO_SEC                       = 1083
	MySqlParserTOUCHES                           = 1084
	MySqlParserTO_BASE64                         = 1085
	MySqlParserTO_DAYS                           = 1086
	MySqlParserTO_SECONDS                        = 1087
	MySqlParserTP_CONNECTION_ADMIN               = 1088
	MySqlParserUCASE                             = 1089
	MySqlParserUNCOMPRESS                        = 1090
	MySqlParserUNCOMPRESSED_LENGTH               = 1091
	MySqlParserUNHEX                             = 1092
	MySqlParserUNIX_TIMESTAMP                    = 1093
	MySqlParserUPDATEXML                         = 1094
	MySqlParserUPPER                             = 1095
	MySqlParserUUID                              = 1096
	MySqlParserUUID_SHORT                        = 1097
	MySqlParserVALIDATE_PASSWORD_STRENGTH        = 1098
	MySqlParserVERSION                           = 1099
	MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS = 1100
	MySqlParserWEEKDAY                           = 1101
	MySqlParserWEEKOFYEAR                        = 1102
	MySqlParserWEIGHT_STRING                     = 1103
	MySqlParserWITHIN                            = 1104
	MySqlParserYEARWEEK                          = 1105
	MySqlParserY_FUNCTION                        = 1106
	MySqlParserX_FUNCTION                        = 1107
	MySqlParserVAR_ASSIGN                        = 1108
	MySqlParserPLUS_ASSIGN                       = 1109
	MySqlParserMINUS_ASSIGN                      = 1110
	MySqlParserMULT_ASSIGN                       = 1111
	MySqlParserDIV_ASSIGN                        = 1112
	MySqlParserMOD_ASSIGN                        = 1113
	MySqlParserAND_ASSIGN                        = 1114
	MySqlParserXOR_ASSIGN                        = 1115
	MySqlParserOR_ASSIGN                         = 1116
	MySqlParserSTAR                              = 1117
	MySqlParserDIVIDE                            = 1118
	MySqlParserMODULE                            = 1119
	MySqlParserPLUS                              = 1120
	MySqlParserMINUS                             = 1121
	MySqlParserDIV                               = 1122
	MySqlParserMOD                               = 1123
	MySqlParserEQUAL_SYMBOL                      = 1124
	MySqlParserGREATER_SYMBOL                    = 1125
	MySqlParserLESS_SYMBOL                       = 1126
	MySqlParserEXCLAMATION_SYMBOL                = 1127
	MySqlParserBIT_NOT_OP                        = 1128
	MySqlParserBIT_OR_OP                         = 1129
	MySqlParserBIT_AND_OP                        = 1130
	MySqlParserBIT_XOR_OP                        = 1131
	MySqlParserDOT                               = 1132
	MySqlParserLR_BRACKET                        = 1133
	MySqlParserRR_BRACKET                        = 1134
	MySqlParserCOMMA                             = 1135
	MySqlParserSEMI                              = 1136
	MySqlParserAT_SIGN                           = 1137
	MySqlParserZERO_DECIMAL                      = 1138
	MySqlParserONE_DECIMAL                       = 1139
	MySqlParserTWO_DECIMAL                       = 1140
	MySqlParserSINGLE_QUOTE_SYMB                 = 1141
	MySqlParserDOUBLE_QUOTE_SYMB                 = 1142
	MySqlParserREVERSE_QUOTE_SYMB                = 1143
	MySqlParserCOLON_SYMB                        = 1144
	MySqlParserCHARSET_REVERSE_QOUTE_STRING      = 1145
	MySqlParserFILESIZE_LITERAL                  = 1146
	MySqlParserSTART_NATIONAL_STRING_LITERAL     = 1147
	MySqlParserSTRING_LITERAL                    = 1148
	MySqlParserDECIMAL_LITERAL                   = 1149
	MySqlParserHEXADECIMAL_LITERAL               = 1150
	MySqlParserREAL_LITERAL                      = 1151
	MySqlParserNULL_SPEC_LITERAL                 = 1152
	MySqlParserBIT_STRING                        = 1153
	MySqlParserSTRING_CHARSET_NAME               = 1154
	MySqlParserDOT_ID                            = 1155
	MySqlParserID                                = 1156
	MySqlParserREVERSE_QUOTE_ID                  = 1157
	MySqlParserHOST_IP_ADDRESS                   = 1158
	MySqlParserLOCAL_ID                          = 1159
	MySqlParserGLOBAL_ID                         = 1160
	MySqlParserERROR_RECONGNIGION                = 1161
)

// 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 (s *RootContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitRoot(s)

	default:
		return t.VisitChildren(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-344)) & ^0x3f) == 0 && ((int64(1)<<(_la-344))&36099165796700291) != 0) || ((int64((_la-432)) & ^0x3f) == 0 && ((int64(1)<<(_la-432))&16782337) != 0) || ((int64((_la-560)) & ^0x3f) == 0 && ((int64(1)<<(_la-560))&17730162917377) != 0) || ((int64((_la-629)) & ^0x3f) == 0 && ((int64(1)<<(_la-629))&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 (s *SqlStatementsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSqlStatements(s)

	default:
		return t.VisitChildren(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 (s *SqlStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSqlStatement(s)

	default:
		return t.VisitChildren(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 (s *EmptyStatement_Context) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitEmptyStatement_(s)

	default:
		return t.VisitChildren(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 (s *DdlStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitDdlStatement(s)

	default:
		return t.VisitChildren(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 (s *DmlStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitDmlStatement(s)

	default:
		return t.VisitChildren(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 (s *TransactionStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTransactionStatement(s)

	default:
		return t.VisitChildren(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 (s *ReplicationStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitReplicationStatement(s)

	default:
		return t.VisitChildren(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 (s *PreparedStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitPreparedStatement(s)

	default:
		return t.VisitChildren(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 (s *CompoundStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCompoundStatement(s)

	default:
		return t.VisitChildren(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 (s *AdministrationStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAdministrationStatement(s)

	default:
		return t.VisitChildren(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 (s *UtilityStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitUtilityStatement(s)

	default:
		return t.VisitChildren(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 (s *CreateDatabaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCreateDatabase(s)

	default:
		return t.VisitChildren(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 (s *CreateEventContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCreateEvent(s)

	default:
		return t.VisitChildren(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 (s *CreateIndexContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCreateIndex(s)

	default:
		return t.VisitChildren(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 (s *CreateLogfileGroupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCreateLogfileGroup(s)

	default:
		return t.VisitChildren(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 (s *CreateProcedureContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCreateProcedure(s)

	default:
		return t.VisitChildren(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))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 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))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&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 (s *CreateFunctionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCreateFunction(s)

	default:
		return t.VisitChildren(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))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 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))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&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, 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, 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, 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 (s *CreateRoleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCreateRole(s)

	default:
		return t.VisitChildren(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 (s *CreateServerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCreateServer(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *CopyCreateTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCopyCreateTable(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *ColumnCreateTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitColumnCreateTable(s)

	default:
		return t.VisitChildren(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 (s *QueryCreateTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitQueryCreateTable(s)

	default:
		return t.VisitChildren(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-341)) & ^0x3f) == 0 && ((int64(1)<<(_la-341))&4644375904747527) != 0) || ((int64((_la-405)) & ^0x3f) == 0 && ((int64(1)<<(_la-405))&4612811918334230547) != 0) || ((int64((_la-500)) & ^0x3f) == 0 && ((int64(1)<<(_la-500))&2366149022974977) != 0) || ((int64((_la-602)) & ^0x3f) == 0 && ((int64(1)<<(_la-602))&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-341)) & ^0x3f) == 0 && ((int64(1)<<(_la-341))&4644375904747527) != 0) || ((int64((_la-405)) & ^0x3f) == 0 && ((int64(1)<<(_la-405))&4612811918334230547) != 0) || ((int64((_la-500)) & ^0x3f) == 0 && ((int64(1)<<(_la-500))&2366149022974977) != 0) || ((int64((_la-602)) & ^0x3f) == 0 && ((int64(1)<<(_la-602))&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 (s *CreateTablespaceInnodbContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCreateTablespaceInnodb(s)

	default:
		return t.VisitChildren(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 (s *CreateTablespaceNdbContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCreateTablespaceNdb(s)

	default:
		return t.VisitChildren(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 (s *CreateTriggerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCreateTrigger(s)

	default:
		return t.VisitChildren(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 (s *WithClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitWithClause(s)

	default:
		return t.VisitChildren(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 (s *CommonTableExpressionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCommonTableExpressions(s)

	default:
		return t.VisitChildren(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 (s *CteNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCteName(s)

	default:
		return t.VisitChildren(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 (s *CteColumnNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCteColumnName(s)

	default:
		return t.VisitChildren(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 (s *CreateViewContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCreateView(s)

	default:
		return t.VisitChildren(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 (s *CreateDatabaseOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCreateDatabaseOption(s)

	default:
		return t.VisitChildren(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 (s *CharSetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCharSet(s)

	default:
		return t.VisitChildren(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 (s *CurrentUserExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCurrentUserExpression(s)

	default:
		return t.VisitChildren(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 (s *OwnerStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitOwnerStatement(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *PreciseScheduleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitPreciseSchedule(s)

	default:
		return t.VisitChildren(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 (s *IntervalScheduleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitIntervalSchedule(s)

	default:
		return t.VisitChildren(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 (s *TimestampValueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTimestampValue(s)

	default:
		return t.VisitChildren(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 (s *IntervalExprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitIntervalExpr(s)

	default:
		return t.VisitChildren(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 (s *IntervalTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitIntervalType(s)

	default:
		return t.VisitChildren(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 (s *EnableTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitEnableType(s)

	default:
		return t.VisitChildren(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 (s *IndexTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitIndexType(s)

	default:
		return t.VisitChildren(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 (s *IndexOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitIndexOption(s)

	default:
		return t.VisitChildren(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 (s *ProcedureParameterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitProcedureParameter(s)

	default:
		return t.VisitChildren(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 (s *FunctionParameterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitFunctionParameter(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *RoutineBehaviorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitRoutineBehavior(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *RoutineLanguageContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitRoutineLanguage(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *RoutineCommentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitRoutineComment(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *RoutineSecurityContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitRoutineSecurity(s)

	default:
		return t.VisitChildren(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 (s *RoutineDataContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitRoutineData(s)

	default:
		return t.VisitChildren(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 (s *ServerOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitServerOption(s)

	default:
		return t.VisitChildren(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 (s *CreateDefinitionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCreateDefinitions(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *ColumnDeclarationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitColumnDeclaration(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *ConstraintDeclarationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitConstraintDeclaration(s)

	default:
		return t.VisitChildren(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 (s *IndexDeclarationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitIndexDeclaration(s)

	default:
		return t.VisitChildren(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 (s *ColumnDefinitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitColumnDefinition(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *StorageColumnConstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitStorageColumnConstraint(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *VisibilityColumnConstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitVisibilityColumnConstraint(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AutoIncrementColumnConstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAutoIncrementColumnConstraint(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *CommentColumnConstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCommentColumnConstraint(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *UniqueKeyColumnConstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitUniqueKeyColumnConstraint(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *SerialDefaultColumnConstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSerialDefaultColumnConstraint(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *GeneratedColumnConstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitGeneratedColumnConstraint(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *FormatColumnConstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitFormatColumnConstraint(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *CollateColumnConstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCollateColumnConstraint(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *PrimaryKeyColumnConstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitPrimaryKeyColumnConstraint(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *CheckColumnConstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCheckColumnConstraint(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *NullColumnConstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitNullColumnConstraint(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *DefaultColumnConstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitDefaultColumnConstraint(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *ReferenceColumnConstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitReferenceColumnConstraint(s)

	default:
		return t.VisitChildren(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 (s *InvisibilityColumnConstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitInvisibilityColumnConstraint(s)

	default:
		return t.VisitChildren(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))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 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))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&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)
	}
}

func (s *UniqueKeyTableConstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitUniqueKeyTableConstraint(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *CheckTableConstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCheckTableConstraint(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *PrimaryKeyTableConstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitPrimaryKeyTableConstraint(s)

	default:
		return t.VisitChildren(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 (s *ForeignKeyTableConstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitForeignKeyTableConstraint(s)

	default:
		return t.VisitChildren(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))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 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))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&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))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 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))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&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))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 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))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&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))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 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))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&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))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 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))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&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))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 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))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&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 (s *ReferenceDefinitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitReferenceDefinition(s)

	default:
		return t.VisitChildren(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 (s *ReferenceActionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitReferenceAction(s)

	default:
		return t.VisitChildren(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 (s *ReferenceControlTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitReferenceControlType(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *SpecialIndexDeclarationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSpecialIndexDeclaration(s)

	default:
		return t.VisitChildren(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 (s *SimpleIndexDeclarationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSimpleIndexDeclaration(s)

	default:
		return t.VisitChildren(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))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 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))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&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))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 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))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&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)
	}
}

func (s *TableOptionEngineContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTableOptionEngine(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *TableOptionMaxRowsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTableOptionMaxRows(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *TableOptionCollateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTableOptionCollate(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *TableOptionPersistentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTableOptionPersistent(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *TableOptionTablespaceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTableOptionTablespace(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *TableOptionAutoextendSizeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTableOptionAutoextendSize(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *TableOptionPageCompressedContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTableOptionPageCompressed(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *TableOptionStartTransactionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTableOptionStartTransaction(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *TableOptionPackKeysContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTableOptionPackKeys(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *TableOptionPasswordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTableOptionPassword(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *TableOptionUnionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTableOptionUnion(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *TableOptionSamplePageContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTableOptionSamplePage(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *TableOptionCharsetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTableOptionCharset(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *TableOptionIndexDirectoryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTableOptionIndexDirectory(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *TableOptionTableTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTableOptionTableType(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *TableOptionKeyBlockSizeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTableOptionKeyBlockSize(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *TableOptionEncryptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTableOptionEncryption(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *TableOptionDataDirectoryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTableOptionDataDirectory(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *TableOptionRecalculationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTableOptionRecalculation(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *TableOptionAutoIncrementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTableOptionAutoIncrement(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *TableOptionEncryptionKeyIdContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTableOptionEncryptionKeyId(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *TableOptionChecksumContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTableOptionChecksum(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *TableOptionDelayContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTableOptionDelay(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *TableOptionConnectionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTableOptionConnection(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *TableOptionTransactionalContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTableOptionTransactional(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *TableOptionPageCompressionLevelContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTableOptionPageCompressionLevel(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *TableOptionSecondaryEngineAttributeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTableOptionSecondaryEngineAttribute(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *TableOptionCommentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTableOptionComment(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *TableOptionAverageContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTableOptionAverage(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *TableOptionRowFormatContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTableOptionRowFormat(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *TableOptionCompressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTableOptionCompression(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *TableOptionInsertMethodContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTableOptionInsertMethod(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *TableOptionEngineAttributeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTableOptionEngineAttribute(s)

	default:
		return t.VisitChildren(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 (s *TableOptionMinRowsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTableOptionMinRows(s)

	default:
		return t.VisitChildren(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-370)) & ^0x3f) == 0 && ((int64(1)<<(_la-370))&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 (s *TableTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTableType(s)

	default:
		return t.VisitChildren(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 (s *TablespaceStorageContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTablespaceStorage(s)

	default:
		return t.VisitChildren(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 (s *PartitionDefinitionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitPartitionDefinitions(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *PartitionFunctionKeyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitPartitionFunctionKey(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *PartitionFunctionHashContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitPartitionFunctionHash(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *PartitionFunctionListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitPartitionFunctionList(s)

	default:
		return t.VisitChildren(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 (s *PartitionFunctionRangeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitPartitionFunctionRange(s)

	default:
		return t.VisitChildren(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))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 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))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&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)
	}
}

func (s *SubPartitionFunctionHashContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSubPartitionFunctionHash(s)

	default:
		return t.VisitChildren(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 (s *SubPartitionFunctionKeyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSubPartitionFunctionKey(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *PartitionComparisonContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitPartitionComparison(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *PartitionListAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitPartitionListAtom(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *PartitionListVectorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitPartitionListVector(s)

	default:
		return t.VisitChildren(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 (s *PartitionSimpleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitPartitionSimple(s)

	default:
		return t.VisitChildren(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-368)) & ^0x3f) == 0 && ((int64(1)<<(_la-368))&2199024304129) != 0) || ((int64((_la-500)) & ^0x3f) == 0 && ((int64(1)<<(_la-500))&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-368)) & ^0x3f) == 0 && ((int64(1)<<(_la-368))&2199024304129) != 0) || ((int64((_la-500)) & ^0x3f) == 0 && ((int64(1)<<(_la-500))&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-368)) & ^0x3f) == 0 && ((int64(1)<<(_la-368))&2199024304129) != 0) || ((int64((_la-500)) & ^0x3f) == 0 && ((int64(1)<<(_la-500))&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-368)) & ^0x3f) == 0 && ((int64(1)<<(_la-368))&2199024304129) != 0) || ((int64((_la-500)) & ^0x3f) == 0 && ((int64(1)<<(_la-500))&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-368)) & ^0x3f) == 0 && ((int64(1)<<(_la-368))&2199024304129) != 0) || ((int64((_la-500)) & ^0x3f) == 0 && ((int64(1)<<(_la-500))&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 (s *PartitionDefinerAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitPartitionDefinerAtom(s)

	default:
		return t.VisitChildren(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 (s *PartitionDefinerVectorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitPartitionDefinerVector(s)

	default:
		return t.VisitChildren(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 (s *SubpartitionDefinitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSubpartitionDefinition(s)

	default:
		return t.VisitChildren(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-368)) & ^0x3f) == 0 && ((int64(1)<<(_la-368))&2199024304129) != 0) || ((int64((_la-500)) & ^0x3f) == 0 && ((int64(1)<<(_la-500))&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)
	}
}

func (s *PartitionOptionCommentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitPartitionOptionComment(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *PartitionOptionNodeGroupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitPartitionOptionNodeGroup(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *PartitionOptionIndexDirectoryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitPartitionOptionIndexDirectory(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *PartitionOptionMaxRowsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitPartitionOptionMaxRows(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *PartitionOptionTablespaceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitPartitionOptionTablespace(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *PartitionOptionEngineContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitPartitionOptionEngine(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *PartitionOptionMinRowsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitPartitionOptionMinRows(s)

	default:
		return t.VisitChildren(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 (s *PartitionOptionDataDirectoryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitPartitionOptionDataDirectory(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterUpgradeNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterUpgradeName(s)

	default:
		return t.VisitChildren(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 (s *AlterSimpleDatabaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterSimpleDatabase(s)

	default:
		return t.VisitChildren(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 (s *AlterEventContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterEvent(s)

	default:
		return t.VisitChildren(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 (s *AlterFunctionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterFunction(s)

	default:
		return t.VisitChildren(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 (s *AlterInstanceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterInstance(s)

	default:
		return t.VisitChildren(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 (s *AlterLogfileGroupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterLogfileGroup(s)

	default:
		return t.VisitChildren(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 (s *AlterProcedureContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterProcedure(s)

	default:
		return t.VisitChildren(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 (s *AlterServerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterServer(s)

	default:
		return t.VisitChildren(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 (s *AlterTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterTable(s)

	default:
		return t.VisitChildren(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 (s *AlterTablespaceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterTablespace(s)

	default:
		return t.VisitChildren(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 (s *AlterViewContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterView(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterByAlterColumnDefaultContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByAlterColumnDefault(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterByDisableKeysContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByDisableKeys(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterByDefaultCharsetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByDefaultCharset(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterByRenameColumnContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByRenameColumn(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterByConvertCharsetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByConvertCharset(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterByAddForeignKeyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByAddForeignKey(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterByRenameIndexContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByRenameIndex(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterByRenameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByRename(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterByImportTablespaceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByImportTablespace(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterByAddDefinitionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByAddDefinitions(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterByAlterCheckTableConstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByAlterCheckTableConstraint(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterByDropConstraintCheckContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByDropConstraintCheck(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterByAddColumnsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByAddColumns(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterByAlterIndexVisibilityContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByAlterIndexVisibility(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterByDropForeignKeyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByDropForeignKey(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterByAddCheckTableConstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByAddCheckTableConstraint(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterPartitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterPartition(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterByAddIndexContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByAddIndex(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterByDropColumnContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByDropColumn(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterByChangeDefaultContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByChangeDefault(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterByForceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByForce(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterByAddSpecialIndexContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByAddSpecialIndex(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterByModifyColumnContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByModifyColumn(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterByTableOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByTableOption(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterByDropPrimaryKeyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByDropPrimaryKey(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterByLockContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByLock(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterByDiscardTablespaceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByDiscardTablespace(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterByValidateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByValidate(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterByAddPrimaryKeyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByAddPrimaryKey(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterByEnableKeysContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByEnableKeys(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterBySetAlgorithmContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterBySetAlgorithm(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterByChangeColumnContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByChangeColumn(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterByAddUniqueKeyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByAddUniqueKey(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterByDropIndexContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByDropIndex(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterByAddColumnContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByAddColumn(s)

	default:
		return t.VisitChildren(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 (s *AlterByOrderContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByOrder(s)

	default:
		return t.VisitChildren(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))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 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))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&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))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 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))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&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))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 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))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&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))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 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))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&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))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 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))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&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))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 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))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&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))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 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))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&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))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 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))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&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))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 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))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&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))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 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))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&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)
	}
}

func (s *AlterByImportPartitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByImportPartition(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterByDropPartitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByDropPartition(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterByDiscardPartitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByDiscardPartition(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterByAddPartitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByAddPartition(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterByRemovePartitioningContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByRemovePartitioning(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterByOptimizePartitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByOptimizePartition(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterByCheckPartitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByCheckPartition(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterByCoalescePartitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByCoalescePartition(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterByReorganizePartitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByReorganizePartition(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterByAnalyzePartitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByAnalyzePartition(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterByRebuildPartitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByRebuildPartition(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterByUpgradePartitioningContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByUpgradePartitioning(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterByTruncatePartitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByTruncatePartition(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterByRepairPartitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByRepairPartition(s)

	default:
		return t.VisitChildren(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 (s *AlterByExchangePartitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterByExchangePartition(s)

	default:
		return t.VisitChildren(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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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 (s *DropDatabaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitDropDatabase(s)

	default:
		return t.VisitChildren(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 (s *DropEventContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitDropEvent(s)

	default:
		return t.VisitChildren(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 (s *DropIndexContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitDropIndex(s)

	default:
		return t.VisitChildren(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 (s *DropLogfileGroupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitDropLogfileGroup(s)

	default:
		return t.VisitChildren(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 (s *DropProcedureContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitDropProcedure(s)

	default:
		return t.VisitChildren(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 (s *DropFunctionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitDropFunction(s)

	default:
		return t.VisitChildren(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 (s *DropServerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitDropServer(s)

	default:
		return t.VisitChildren(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 (s *DropTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitDropTable(s)

	default:
		return t.VisitChildren(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 (s *DropTablespaceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitDropTablespace(s)

	default:
		return t.VisitChildren(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 (s *DropTriggerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitDropTrigger(s)

	default:
		return t.VisitChildren(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 (s *DropViewContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitDropView(s)

	default:
		return t.VisitChildren(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 (s *DropRoleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitDropRole(s)

	default:
		return t.VisitChildren(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 (s *SetRoleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSetRole(s)

	default:
		return t.VisitChildren(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 (s *RenameTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitRenameTable(s)

	default:
		return t.VisitChildren(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 (s *RenameTableClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitRenameTableClause(s)

	default:
		return t.VisitChildren(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 (s *TruncateTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTruncateTable(s)

	default:
		return t.VisitChildren(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 (s *CallStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCallStatement(s)

	default:
		return t.VisitChildren(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 (s *DeleteStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitDeleteStatement(s)

	default:
		return t.VisitChildren(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 (s *DoStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitDoStatement(s)

	default:
		return t.VisitChildren(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 (s *HandlerStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitHandlerStatement(s)

	default:
		return t.VisitChildren(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 (s *InsertStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitInsertStatement(s)

	default:
		return t.VisitChildren(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))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 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))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&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 (s *LoadDataStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitLoadDataStatement(s)

	default:
		return t.VisitChildren(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 (s *LoadXmlStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitLoadXmlStatement(s)

	default:
		return t.VisitChildren(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 (s *ReplaceStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitReplaceStatement(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *UnionSelectContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitUnionSelect(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *UnionParenthesisSelectContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitUnionParenthesisSelect(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *SimpleSelectContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSimpleSelect(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *ParenthesisSelectContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitParenthesisSelect(s)

	default:
		return t.VisitChildren(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 (s *WithLateralStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitWithLateralStatement(s)

	default:
		return t.VisitChildren(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 (s *UpdateStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitUpdateStatement(s)

	default:
		return t.VisitChildren(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 (s *ValuesStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitValuesStatement(s)

	default:
		return t.VisitChildren(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 (s *InsertStatementValueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitInsertStatementValue(s)

	default:
		return t.VisitChildren(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 (s *UpdatedElementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitUpdatedElement(s)

	default:
		return t.VisitChildren(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 (s *AssignmentFieldContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAssignmentField(s)

	default:
		return t.VisitChildren(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, 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, 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, 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 (s *LockClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitLockClause(s)

	default:
		return t.VisitChildren(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 (s *SingleDeleteStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSingleDeleteStatement(s)

	default:
		return t.VisitChildren(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 (s *MultipleDeleteStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitMultipleDeleteStatement(s)

	default:
		return t.VisitChildren(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, 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, 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, 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 (s *HandlerOpenStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitHandlerOpenStatement(s)

	default:
		return t.VisitChildren(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 (s *HandlerReadIndexStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitHandlerReadIndexStatement(s)

	default:
		return t.VisitChildren(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 (s *HandlerReadStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitHandlerReadStatement(s)

	default:
		return t.VisitChildren(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 (s *HandlerCloseStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitHandlerCloseStatement(s)

	default:
		return t.VisitChildren(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 (s *SingleUpdateStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSingleUpdateStatement(s)

	default:
		return t.VisitChildren(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))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 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))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&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 (s *MultipleUpdateStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitMultipleUpdateStatement(s)

	default:
		return t.VisitChildren(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 (s *OrderByClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitOrderByClause(s)

	default:
		return t.VisitChildren(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 (s *OrderByExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitOrderByExpression(s)

	default:
		return t.VisitChildren(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 (s *TableSourcesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTableSources(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *TableJsonContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTableJson(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *TableSourceNestedContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTableSourceNested(s)

	default:
		return t.VisitChildren(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 (s *TableSourceBaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTableSourceBase(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *SubqueryTableItemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSubqueryTableItem(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AtomTableItemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAtomTableItem(s)

	default:
		return t.VisitChildren(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 (s *TableSourcesItemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTableSourcesItem(s)

	default:
		return t.VisitChildren(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 (s *IndexHintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitIndexHint(s)

	default:
		return t.VisitChildren(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 (s *IndexHintTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitIndexHintType(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *InnerJoinContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitInnerJoin(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *NaturalJoinContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitNaturalJoin(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *OuterJoinContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitOuterJoin(s)

	default:
		return t.VisitChildren(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 (s *StraightJoinContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitStraightJoin(s)

	default:
		return t.VisitChildren(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 (s *JoinSpecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitJoinSpec(s)

	default:
		return t.VisitChildren(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 (s *QueryExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitQueryExpression(s)

	default:
		return t.VisitChildren(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 (s *QueryExpressionNointoContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitQueryExpressionNointo(s)

	default:
		return t.VisitChildren(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 (s *QuerySpecificationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitQuerySpecification(s)

	default:
		return t.VisitChildren(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 (s *QuerySpecificationNointoContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitQuerySpecificationNointo(s)

	default:
		return t.VisitChildren(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 (s *UnionParenthesisContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitUnionParenthesis(s)

	default:
		return t.VisitChildren(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 (s *UnionStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitUnionStatement(s)

	default:
		return t.VisitChildren(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 (s *LateralStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitLateralStatement(s)

	default:
		return t.VisitChildren(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 (s *JsonTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitJsonTable(s)

	default:
		return t.VisitChildren(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 (s *JsonColumnListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitJsonColumnList(s)

	default:
		return t.VisitChildren(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 (s *JsonColumnContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitJsonColumn(s)

	default:
		return t.VisitChildren(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, 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 (s *JsonOnEmptyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitJsonOnEmpty(s)

	default:
		return t.VisitChildren(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 (s *JsonOnErrorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitJsonOnError(s)

	default:
		return t.VisitChildren(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 (s *SelectSpecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSelectSpec(s)

	default:
		return t.VisitChildren(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 (s *SelectElementsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSelectElements(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *SelectExpressionElementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSelectExpressionElement(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *SelectFunctionElementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSelectFunctionElement(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *SelectStarElementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSelectStarElement(s)

	default:
		return t.VisitChildren(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 (s *SelectColumnElementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSelectColumnElement(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *SelectIntoVariablesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSelectIntoVariables(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *SelectIntoTextFileContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSelectIntoTextFile(s)

	default:
		return t.VisitChildren(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 (s *SelectIntoDumpFileContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSelectIntoDumpFile(s)

	default:
		return t.VisitChildren(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 (s *SelectFieldsIntoContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSelectFieldsInto(s)

	default:
		return t.VisitChildren(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 (s *SelectLinesIntoContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSelectLinesInto(s)

	default:
		return t.VisitChildren(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 (s *FromClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitFromClause(s)

	default:
		return t.VisitChildren(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 (s *GroupByClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitGroupByClause(s)

	default:
		return t.VisitChildren(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 (s *HavingClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitHavingClause(s)

	default:
		return t.VisitChildren(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 (s *WindowClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitWindowClause(s)

	default:
		return t.VisitChildren(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 (s *GroupByItemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitGroupByItem(s)

	default:
		return t.VisitChildren(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 (s *LimitClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitLimitClause(s)

	default:
		return t.VisitChildren(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 (s *LimitClauseAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitLimitClauseAtom(s)

	default:
		return t.VisitChildren(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, 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, 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, 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 (s *StartTransactionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitStartTransaction(s)

	default:
		return t.VisitChildren(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 (s *BeginWorkContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitBeginWork(s)

	default:
		return t.VisitChildren(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 (s *CommitWorkContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCommitWork(s)

	default:
		return t.VisitChildren(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 (s *RollbackWorkContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitRollbackWork(s)

	default:
		return t.VisitChildren(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 (s *SavepointStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSavepointStatement(s)

	default:
		return t.VisitChildren(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 (s *RollbackStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitRollbackStatement(s)

	default:
		return t.VisitChildren(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 (s *ReleaseStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitReleaseStatement(s)

	default:
		return t.VisitChildren(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 (s *LockTablesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitLockTables(s)

	default:
		return t.VisitChildren(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 (s *UnlockTablesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitUnlockTables(s)

	default:
		return t.VisitChildren(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 (s *SetAutocommitStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSetAutocommitStatement(s)

	default:
		return t.VisitChildren(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 (s *SetTransactionStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSetTransactionStatement(s)

	default:
		return t.VisitChildren(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 (s *TransactionModeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTransactionMode(s)

	default:
		return t.VisitChildren(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 (s *LockTableElementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitLockTableElement(s)

	default:
		return t.VisitChildren(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))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 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))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&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 (s *LockActionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitLockAction(s)

	default:
		return t.VisitChildren(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 (s *TransactionOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTransactionOption(s)

	default:
		return t.VisitChildren(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 (s *TransactionLevelContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTransactionLevel(s)

	default:
		return t.VisitChildren(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 (s *ChangeMasterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitChangeMaster(s)

	default:
		return t.VisitChildren(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 (s *ChangeReplicationFilterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitChangeReplicationFilter(s)

	default:
		return t.VisitChildren(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 (s *PurgeBinaryLogsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitPurgeBinaryLogs(s)

	default:
		return t.VisitChildren(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 (s *ResetMasterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitResetMaster(s)

	default:
		return t.VisitChildren(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 (s *ResetSlaveContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitResetSlave(s)

	default:
		return t.VisitChildren(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 (s *StartSlaveContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitStartSlave(s)

	default:
		return t.VisitChildren(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 (s *StopSlaveContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitStopSlave(s)

	default:
		return t.VisitChildren(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 (s *StartGroupReplicationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitStartGroupReplication(s)

	default:
		return t.VisitChildren(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 (s *StopGroupReplicationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitStopGroupReplication(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *MasterStringOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitMasterStringOption(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *MasterRealOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitMasterRealOption(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *MasterBoolOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitMasterBoolOption(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *MasterUidListOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitMasterUidListOption(s)

	default:
		return t.VisitChildren(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 (s *MasterDecimalOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitMasterDecimalOption(s)

	default:
		return t.VisitChildren(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))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 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))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&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 (s *StringMasterOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitStringMasterOption(s)

	default:
		return t.VisitChildren(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-482)) & ^0x3f) == 0 && ((int64(1)<<(_la-482))&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 (s *DecimalMasterOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitDecimalMasterOption(s)

	default:
		return t.VisitChildren(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-479)) & ^0x3f) == 0 && ((int64(1)<<(_la-479))&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 (s *BoolMasterOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitBoolMasterOption(s)

	default:
		return t.VisitChildren(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 (s *ChannelOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitChannelOption(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *WildIgnoreTableReplicationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitWildIgnoreTableReplication(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *DoTableReplicationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitDoTableReplication(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *IgnoreTableReplicationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitIgnoreTableReplication(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *RewriteDbReplicationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitRewriteDbReplication(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *DoDbReplicationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitDoDbReplication(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *IgnoreDbReplicationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitIgnoreDbReplication(s)

	default:
		return t.VisitChildren(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 (s *WildDoTableReplicationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitWildDoTableReplication(s)

	default:
		return t.VisitChildren(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 (s *TablePairContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTablePair(s)

	default:
		return t.VisitChildren(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 (s *ThreadTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitThreadType(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *GtidsUntilOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitGtidsUntilOption(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *SqlGapsUntilOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSqlGapsUntilOption(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *MasterLogUntilOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitMasterLogUntilOption(s)

	default:
		return t.VisitChildren(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 (s *RelayLogUntilOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitRelayLogUntilOption(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *PluginDirConnectionOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitPluginDirConnectionOption(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *UserConnectionOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitUserConnectionOption(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *DefaultAuthConnectionOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitDefaultAuthConnectionOption(s)

	default:
		return t.VisitChildren(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 (s *PasswordConnectionOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitPasswordConnectionOption(s)

	default:
		return t.VisitChildren(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 (s *GtuidSetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitGtuidSet(s)

	default:
		return t.VisitChildren(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 (s *XaStartTransactionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitXaStartTransaction(s)

	default:
		return t.VisitChildren(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 (s *XaEndTransactionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitXaEndTransaction(s)

	default:
		return t.VisitChildren(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 (s *XaPrepareStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitXaPrepareStatement(s)

	default:
		return t.VisitChildren(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 (s *XaCommitWorkContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitXaCommitWork(s)

	default:
		return t.VisitChildren(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 (s *XaRollbackWorkContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitXaRollbackWork(s)

	default:
		return t.VisitChildren(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 (s *XaRecoverWorkContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitXaRecoverWork(s)

	default:
		return t.VisitChildren(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 (s *PrepareStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitPrepareStatement(s)

	default:
		return t.VisitChildren(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 (s *ExecuteStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitExecuteStatement(s)

	default:
		return t.VisitChildren(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 (s *DeallocatePrepareContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitDeallocatePrepare(s)

	default:
		return t.VisitChildren(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 (s *RoutineBodyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitRoutineBody(s)

	default:
		return t.VisitChildren(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 (s *BlockStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitBlockStatement(s)

	default:
		return t.VisitChildren(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 (s *CaseStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCaseStatement(s)

	default:
		return t.VisitChildren(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 (s *IfStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitIfStatement(s)

	default:
		return t.VisitChildren(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 (s *IterateStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitIterateStatement(s)

	default:
		return t.VisitChildren(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 (s *LeaveStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitLeaveStatement(s)

	default:
		return t.VisitChildren(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 (s *LoopStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitLoopStatement(s)

	default:
		return t.VisitChildren(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))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 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))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&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))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 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))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&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 (s *RepeatStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitRepeatStatement(s)

	default:
		return t.VisitChildren(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))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 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))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&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 (s *ReturnStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitReturnStatement(s)

	default:
		return t.VisitChildren(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 (s *WhileStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitWhileStatement(s)

	default:
		return t.VisitChildren(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))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 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))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&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))&-17174494689) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&-1099511627777) != 0) || ((int64((_la-345)) & ^0x3f) == 0 && ((int64(1)<<(_la-345))&-2882305960540372993) != 0) || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&-4398063288321) != 0) || ((int64((_la-473)) & ^0x3f) == 0 && ((int64(1)<<(_la-473))&-16325548649218049) != 0) || ((int64((_la-537)) & ^0x3f) == 0 && ((int64(1)<<(_la-537))&-9007199258936065) != 0) || ((int64((_la-601)) & ^0x3f) == 0 && ((int64(1)<<(_la-601))&-68719476801) != 0) || ((int64((_la-665)) & ^0x3f) == 0 && ((int64(1)<<(_la-665))&-22236531750078465) != 0) || ((int64((_la-729)) & ^0x3f) == 0 && ((int64(1)<<(_la-729))&-65) != 0) || ((int64((_la-793)) & ^0x3f) == 0 && ((int64(1)<<(_la-793))&-6145) != 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))&576460752303423487) != 0) || ((int64((_la-1123)) & ^0x3f) == 0 && ((int64(1)<<(_la-1123))&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)
	}
}

func (s *CloseCursorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCloseCursor(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *OpenCursorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitOpenCursor(s)

	default:
		return t.VisitChildren(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 (s *FetchCursorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitFetchCursor(s)

	default:
		return t.VisitChildren(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 (s *DeclareVariableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitDeclareVariable(s)

	default:
		return t.VisitChildren(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 (s *DeclareConditionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitDeclareCondition(s)

	default:
		return t.VisitChildren(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 (s *DeclareCursorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitDeclareCursor(s)

	default:
		return t.VisitChildren(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 (s *DeclareHandlerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitDeclareHandler(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *HandlerConditionWarningContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitHandlerConditionWarning(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *HandlerConditionCodeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitHandlerConditionCode(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *HandlerConditionNotfoundContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitHandlerConditionNotfound(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *HandlerConditionStateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitHandlerConditionState(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *HandlerConditionExceptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitHandlerConditionException(s)

	default:
		return t.VisitChildren(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 (s *HandlerConditionNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitHandlerConditionName(s)

	default:
		return t.VisitChildren(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, 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, 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, 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 (s *ProcedureSqlStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitProcedureSqlStatement(s)

	default:
		return t.VisitChildren(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 (s *CaseAlternativeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCaseAlternative(s)

	default:
		return t.VisitChildren(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 (s *ElifAlternativeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitElifAlternative(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AlterUserMysqlV80Context) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterUserMysqlV80(s)

	default:
		return t.VisitChildren(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 (s *AlterUserMysqlV56Context) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAlterUserMysqlV56(s)

	default:
		return t.VisitChildren(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-498)) & ^0x3f) == 0 && ((int64(1)<<(_la-498))&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)
	}
}

func (s *CreateUserMysqlV56Context) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCreateUserMysqlV56(s)

	default:
		return t.VisitChildren(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 (s *CreateUserMysqlV80Context) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCreateUserMysqlV80(s)

	default:
		return t.VisitChildren(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-498)) & ^0x3f) == 0 && ((int64(1)<<(_la-498))&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 (s *DropUserContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitDropUser(s)

	default:
		return t.VisitChildren(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 (s *GrantStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitGrantStatement(s)

	default:
		return t.VisitChildren(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 (s *RoleOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitRoleOption(s)

	default:
		return t.VisitChildren(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 (s *GrantProxyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitGrantProxy(s)

	default:
		return t.VisitChildren(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 (s *RenameUserContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitRenameUser(s)

	default:
		return t.VisitChildren(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) 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) 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) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(MySqlParserCOMMA)
}

func (s *DetailRevokeContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(MySqlParserCOMMA, i)
}

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)
	}
}

func (s *DetailRevokeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitDetailRevoke(s)

	default:
		return t.VisitChildren(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) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(MySqlParserCOMMA)
}

func (s *RoleRevokeContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(MySqlParserCOMMA, i)
}

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)
	}
}

func (s *RoleRevokeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitRoleRevoke(s)

	default:
		return t.VisitChildren(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) PRIVILEGES() antlr.TerminalNode {
	return s.GetToken(MySqlParserPRIVILEGES, 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 (s *ShortRevokeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitShortRevoke(s)

	default:
		return t.VisitChildren(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(5329)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 788, 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(5260)
			p.PrivelegeClause()
		}
		p.SetState(5265)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		for _la == MySqlParserCOMMA {
			{
				p.SetState(5261)
				p.Match(MySqlParserCOMMA)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(5262)
				p.PrivelegeClause()
			}

			p.SetState(5267)
			p.GetErrorHandler().Sync(p)
			if p.HasError() {
				goto errorExit
			}
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(5268)
			p.Match(MySqlParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(5270)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 778, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(5269)

				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(5272)
			p.PrivilegeLevel()
		}
		{
			p.SetState(5273)
			p.Match(MySqlParserFROM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5274)
			p.UserName()
		}
		p.SetState(5279)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		for _la == MySqlParserCOMMA {
			{
				p.SetState(5275)
				p.Match(MySqlParserCOMMA)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(5276)
				p.UserName()
			}

			p.SetState(5281)
			p.GetErrorHandler().Sync(p)
			if p.HasError() {
				goto errorExit
			}
			_la = p.GetTokenStream().LA(1)
		}

	case 2:
		localctx = NewShortRevokeContext(p, localctx)
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(5282)
			p.Match(MySqlParserREVOKE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5283)
			p.Match(MySqlParserALL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(5285)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserPRIVILEGES {
			{
				p.SetState(5284)
				p.Match(MySqlParserPRIVILEGES)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		}
		{
			p.SetState(5287)
			p.Match(MySqlParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5288)
			p.Match(MySqlParserGRANT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5289)
			p.Match(MySqlParserOPTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5290)
			p.Match(MySqlParserFROM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5291)
			p.UserName()
		}
		p.SetState(5296)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		for _la == MySqlParserCOMMA {
			{
				p.SetState(5292)
				p.Match(MySqlParserCOMMA)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(5293)
				p.UserName()
			}

			p.SetState(5298)
			p.GetErrorHandler().Sync(p)
			if p.HasError() {
				goto errorExit
			}
			_la = p.GetTokenStream().LA(1)
		}

	case 3:
		localctx = NewRoleRevokeContext(p, localctx)
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(5299)
			p.Match(MySqlParserREVOKE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(5302)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 782, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(5300)
				p.UserName()
			}

		case 2:
			{
				p.SetState(5301)
				p.Uid()
			}

		case antlr.ATNInvalidAltNumber:
			goto errorExit
		}
		p.SetState(5311)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		for _la == MySqlParserCOMMA {
			{
				p.SetState(5304)
				p.Match(MySqlParserCOMMA)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			p.SetState(5307)
			p.GetErrorHandler().Sync(p)
			if p.HasError() {
				goto errorExit
			}

			switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 783, p.GetParserRuleContext()) {
			case 1:
				{
					p.SetState(5305)
					p.UserName()
				}

			case 2:
				{
					p.SetState(5306)
					p.Uid()
				}

			case antlr.ATNInvalidAltNumber:
				goto errorExit
			}

			p.SetState(5313)
			p.GetErrorHandler().Sync(p)
			if p.HasError() {
				goto errorExit
			}
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(5314)
			p.Match(MySqlParserFROM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(5317)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 785, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(5315)
				p.UserName()
			}

		case 2:
			{
				p.SetState(5316)
				p.Uid()
			}

		case antlr.ATNInvalidAltNumber:
			goto errorExit
		}
		p.SetState(5326)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		for _la == MySqlParserCOMMA {
			{
				p.SetState(5319)
				p.Match(MySqlParserCOMMA)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			p.SetState(5322)
			p.GetErrorHandler().Sync(p)
			if p.HasError() {
				goto errorExit
			}

			switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 786, p.GetParserRuleContext()) {
			case 1:
				{
					p.SetState(5320)
					p.UserName()
				}

			case 2:
				{
					p.SetState(5321)
					p.Uid()
				}

			case antlr.ATNInvalidAltNumber:
				goto errorExit
			}

			p.SetState(5328)
			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
}

// 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 (s *RevokeProxyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitRevokeProxy(s)

	default:
		return t.VisitChildren(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(5331)
		p.Match(MySqlParserREVOKE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5332)
		p.Match(MySqlParserPROXY)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5333)
		p.Match(MySqlParserON)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5334)

		var _x = p.UserName()

		localctx.(*RevokeProxyContext).onUser = _x
	}
	{
		p.SetState(5335)
		p.Match(MySqlParserFROM)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5336)

		var _x = p.UserName()

		localctx.(*RevokeProxyContext).fromFirst = _x
	}
	p.SetState(5341)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == MySqlParserCOMMA {
		{
			p.SetState(5337)
			p.Match(MySqlParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5338)

			var _x = p.UserName()

			localctx.(*RevokeProxyContext)._userName = _x
		}
		localctx.(*RevokeProxyContext).fromOther = append(localctx.(*RevokeProxyContext).fromOther, localctx.(*RevokeProxyContext)._userName)

		p.SetState(5343)
		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 (s *SetPasswordStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSetPasswordStatement(s)

	default:
		return t.VisitChildren(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(5344)
		p.Match(MySqlParserSET)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5345)
		p.Match(MySqlParserPASSWORD)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(5348)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == MySqlParserFOR {
		{
			p.SetState(5346)
			p.Match(MySqlParserFOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5347)
			p.UserName()
		}

	}
	{
		p.SetState(5350)
		p.Match(MySqlParserEQUAL_SYMBOL)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(5353)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case MySqlParserOLD_PASSWORD, MySqlParserPASSWORD:
		{
			p.SetState(5351)
			p.PasswordFunctionClause()
		}

	case MySqlParserSTRING_LITERAL:
		{
			p.SetState(5352)
			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 (s *UserSpecificationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitUserSpecification(s)

	default:
		return t.VisitChildren(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(5355)
		p.UserName()
	}
	{
		p.SetState(5356)
		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)
	}
}

func (s *SimpleAuthOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSimpleAuthOption(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *ModuleAuthOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitModuleAuthOption(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *RandomAuthOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitRandomAuthOption(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *StringAuthOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitStringAuthOption(s)

	default:
		return t.VisitChildren(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 (s *HashAuthOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitHashAuthOption(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *MySqlParser) UserAuthOption() (localctx IUserAuthOptionContext) {
	localctx = NewUserAuthOptionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 448, MySqlParserRULE_userAuthOption)
	p.SetState(5383)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 792, p.GetParserRuleContext()) {
	case 1:
		localctx = NewHashAuthOptionContext(p, localctx)
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5358)
			p.UserName()
		}
		{
			p.SetState(5359)
			p.Match(MySqlParserIDENTIFIED)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5360)
			p.Match(MySqlParserBY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5361)
			p.Match(MySqlParserPASSWORD)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5362)

			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(5364)
			p.UserName()
		}
		{
			p.SetState(5365)
			p.Match(MySqlParserIDENTIFIED)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5366)
			p.Match(MySqlParserBY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5367)
			p.Match(MySqlParserRANDOM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5368)
			p.Match(MySqlParserPASSWORD)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5369)
			p.AuthOptionClause()
		}

	case 3:
		localctx = NewStringAuthOptionContext(p, localctx)
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(5371)
			p.UserName()
		}
		{
			p.SetState(5372)
			p.Match(MySqlParserIDENTIFIED)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5373)
			p.Match(MySqlParserBY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5374)
			p.Match(MySqlParserSTRING_LITERAL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5375)
			p.AuthOptionClause()
		}

	case 4:
		localctx = NewModuleAuthOptionContext(p, localctx)
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(5377)
			p.UserName()
		}
		{
			p.SetState(5378)
			p.Match(MySqlParserIDENTIFIED)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5379)
			p.Match(MySqlParserWITH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5380)
			p.AuthenticationRule()
		}

	case 5:
		localctx = NewSimpleAuthOptionContext(p, localctx)
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(5382)
			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 (s *AuthOptionClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAuthOptionClause(s)

	default:
		return t.VisitChildren(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(5387)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 793, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(5385)
			p.Match(MySqlParserREPLACE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5386)
			p.Match(MySqlParserSTRING_LITERAL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	} else if p.HasError() { // JIM
		goto errorExit
	}
	p.SetState(5392)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == MySqlParserRETAIN {
		{
			p.SetState(5389)
			p.Match(MySqlParserRETAIN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5390)
			p.Match(MySqlParserCURRENT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5391)
			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)
	}
}

func (s *PasswordModuleOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitPasswordModuleOption(s)

	default:
		return t.VisitChildren(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 (s *ModuleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitModule(s)

	default:
		return t.VisitChildren(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(5408)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 797, p.GetParserRuleContext()) {
	case 1:
		localctx = NewModuleContext(p, localctx)
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5394)
			p.AuthPlugin()
		}
		p.SetState(5402)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 796, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(5395)
				_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(5399)
			p.GetErrorHandler().Sync(p)
			if p.HasError() {
				goto errorExit
			}

			switch p.GetTokenStream().LA(1) {
			case MySqlParserSTRING_LITERAL:
				{
					p.SetState(5396)
					p.Match(MySqlParserSTRING_LITERAL)
					if p.HasError() {
						// Recognition error - abort rule
						goto errorExit
					}
				}

			case MySqlParserRANDOM:
				{
					p.SetState(5397)
					p.Match(MySqlParserRANDOM)
					if p.HasError() {
						// Recognition error - abort rule
						goto errorExit
					}
				}
				{
					p.SetState(5398)
					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(5401)
				p.AuthOptionClause()
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}

	case 2:
		localctx = NewPasswordModuleOptionContext(p, localctx)
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(5404)
			p.AuthPlugin()
		}
		{
			p.SetState(5405)
			p.Match(MySqlParserUSING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5406)
			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 (s *TlsOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTlsOption(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *MySqlParser) TlsOption() (localctx ITlsOptionContext) {
	localctx = NewTlsOptionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 454, MySqlParserRULE_tlsOption)
	p.SetState(5418)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case MySqlParserSSL:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5410)
			p.Match(MySqlParserSSL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserX509:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(5411)
			p.Match(MySqlParserX509)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserCIPHER:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(5412)
			p.Match(MySqlParserCIPHER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5413)
			p.Match(MySqlParserSTRING_LITERAL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserISSUER:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(5414)
			p.Match(MySqlParserISSUER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5415)
			p.Match(MySqlParserSTRING_LITERAL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserSUBJECT:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(5416)
			p.Match(MySqlParserSUBJECT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5417)
			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 (s *UserResourceOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitUserResourceOption(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *MySqlParser) UserResourceOption() (localctx IUserResourceOptionContext) {
	localctx = NewUserResourceOptionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 456, MySqlParserRULE_userResourceOption)
	p.SetState(5428)
	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(5420)
			p.Match(MySqlParserMAX_QUERIES_PER_HOUR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5421)
			p.DecimalLiteral()
		}

	case MySqlParserMAX_UPDATES_PER_HOUR:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(5422)
			p.Match(MySqlParserMAX_UPDATES_PER_HOUR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5423)
			p.DecimalLiteral()
		}

	case MySqlParserMAX_CONNECTIONS_PER_HOUR:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(5424)
			p.Match(MySqlParserMAX_CONNECTIONS_PER_HOUR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5425)
			p.DecimalLiteral()
		}

	case MySqlParserMAX_USER_CONNECTIONS:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(5426)
			p.Match(MySqlParserMAX_USER_CONNECTIONS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5427)
			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 (s *UserPasswordOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitUserPasswordOption(s)

	default:
		return t.VisitChildren(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(5468)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 805, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5430)
			p.Match(MySqlParserPASSWORD)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5431)
			p.Match(MySqlParserEXPIRE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(5438)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		switch p.GetTokenStream().LA(1) {
		case MySqlParserDEFAULT:
			{
				p.SetState(5432)

				var _m = p.Match(MySqlParserDEFAULT)

				localctx.(*UserPasswordOptionContext).expireType = _m
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		case MySqlParserNEVER:
			{
				p.SetState(5433)

				var _m = p.Match(MySqlParserNEVER)

				localctx.(*UserPasswordOptionContext).expireType = _m
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		case MySqlParserINTERVAL:
			{
				p.SetState(5434)

				var _m = p.Match(MySqlParserINTERVAL)

				localctx.(*UserPasswordOptionContext).expireType = _m
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(5435)
				p.DecimalLiteral()
			}
			{
				p.SetState(5436)
				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(5440)
			p.Match(MySqlParserPASSWORD)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5441)
			p.Match(MySqlParserHISTORY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(5444)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetTokenStream().LA(1) {
		case MySqlParserDEFAULT:
			{
				p.SetState(5442)
				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(5443)
				p.DecimalLiteral()
			}

		default:
			p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
			goto errorExit
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(5446)
			p.Match(MySqlParserPASSWORD)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5447)
			p.Match(MySqlParserREUSE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5448)
			p.Match(MySqlParserINTERVAL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(5453)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetTokenStream().LA(1) {
		case MySqlParserDEFAULT:
			{
				p.SetState(5449)
				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(5450)
				p.DecimalLiteral()
			}
			{
				p.SetState(5451)
				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(5455)
			p.Match(MySqlParserPASSWORD)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5456)
			p.Match(MySqlParserREQUIRE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5457)
			p.Match(MySqlParserCURRENT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(5459)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserDEFAULT || _la == MySqlParserOPTIONAL {
			{
				p.SetState(5458)
				_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(5461)
			p.Match(MySqlParserFAILED_LOGIN_ATTEMPTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5462)
			p.DecimalLiteral()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(5463)
			p.Match(MySqlParserPASSWORD_LOCK_TIME)
			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 MySqlParserZERO_DECIMAL, MySqlParserONE_DECIMAL, MySqlParserTWO_DECIMAL, MySqlParserDECIMAL_LITERAL, MySqlParserREAL_LITERAL:
			{
				p.SetState(5464)
				p.DecimalLiteral()
			}

		case MySqlParserUNBOUNDED:
			{
				p.SetState(5465)
				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 (s *UserLockOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitUserLockOption(s)

	default:
		return t.VisitChildren(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(5470)
		p.Match(MySqlParserACCOUNT)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5471)

		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 (s *PrivelegeClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitPrivelegeClause(s)

	default:
		return t.VisitChildren(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(5473)
		p.Privilege()
	}
	p.SetState(5478)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == MySqlParserLR_BRACKET {
		{
			p.SetState(5474)
			p.Match(MySqlParserLR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5475)
			p.UidList()
		}
		{
			p.SetState(5476)
			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 (s *PrivilegeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitPrivilege(s)

	default:
		return t.VisitChildren(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(5573)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 811, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5480)
			p.Match(MySqlParserALL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(5482)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserPRIVILEGES {
			{
				p.SetState(5481)
				p.Match(MySqlParserPRIVILEGES)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(5484)
			p.Match(MySqlParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(5486)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserROUTINE {
			{
				p.SetState(5485)
				p.Match(MySqlParserROUTINE)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(5488)
			p.Match(MySqlParserCREATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(5496)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		switch p.GetTokenStream().LA(1) {
		case MySqlParserTEMPORARY:
			{
				p.SetState(5489)
				p.Match(MySqlParserTEMPORARY)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(5490)
				p.Match(MySqlParserTABLES)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		case MySqlParserROUTINE:
			{
				p.SetState(5491)
				p.Match(MySqlParserROUTINE)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		case MySqlParserVIEW:
			{
				p.SetState(5492)
				p.Match(MySqlParserVIEW)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		case MySqlParserUSER:
			{
				p.SetState(5493)
				p.Match(MySqlParserUSER)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		case MySqlParserTABLESPACE:
			{
				p.SetState(5494)
				p.Match(MySqlParserTABLESPACE)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		case MySqlParserROLE:
			{
				p.SetState(5495)
				p.Match(MySqlParserROLE)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		case MySqlParserON, MySqlParserLR_BRACKET, MySqlParserCOMMA:

		default:
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(5498)
			p.Match(MySqlParserDELETE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(5499)
			p.Match(MySqlParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(5501)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserROLE {
			{
				p.SetState(5500)
				p.Match(MySqlParserROLE)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(5503)
			p.Match(MySqlParserEVENT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(5504)
			p.Match(MySqlParserEXECUTE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(5505)
			p.Match(MySqlParserFILE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 9:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(5506)
			p.Match(MySqlParserGRANT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5507)
			p.Match(MySqlParserOPTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 10:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(5508)
			p.Match(MySqlParserINDEX)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 11:
		p.EnterOuterAlt(localctx, 11)
		{
			p.SetState(5509)
			p.Match(MySqlParserINSERT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 12:
		p.EnterOuterAlt(localctx, 12)
		{
			p.SetState(5510)
			p.Match(MySqlParserLOCK)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5511)
			p.Match(MySqlParserTABLES)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 13:
		p.EnterOuterAlt(localctx, 13)
		{
			p.SetState(5512)
			p.Match(MySqlParserPROCESS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 14:
		p.EnterOuterAlt(localctx, 14)
		{
			p.SetState(5513)
			p.Match(MySqlParserPROXY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 15:
		p.EnterOuterAlt(localctx, 15)
		{
			p.SetState(5514)
			p.Match(MySqlParserREFERENCES)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 16:
		p.EnterOuterAlt(localctx, 16)
		{
			p.SetState(5515)
			p.Match(MySqlParserRELOAD)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 17:
		p.EnterOuterAlt(localctx, 17)
		{
			p.SetState(5516)
			p.Match(MySqlParserREPLICATION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5517)
			_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(5518)
			p.Match(MySqlParserSELECT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 19:
		p.EnterOuterAlt(localctx, 19)
		{
			p.SetState(5519)
			p.Match(MySqlParserSHOW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5520)
			_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(5521)
			p.Match(MySqlParserSHUTDOWN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 21:
		p.EnterOuterAlt(localctx, 21)
		{
			p.SetState(5522)
			p.Match(MySqlParserSUPER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 22:
		p.EnterOuterAlt(localctx, 22)
		{
			p.SetState(5523)
			p.Match(MySqlParserTRIGGER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 23:
		p.EnterOuterAlt(localctx, 23)
		{
			p.SetState(5524)
			p.Match(MySqlParserUPDATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 24:
		p.EnterOuterAlt(localctx, 24)
		{
			p.SetState(5525)
			p.Match(MySqlParserUSAGE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 25:
		p.EnterOuterAlt(localctx, 25)
		{
			p.SetState(5526)
			p.Match(MySqlParserAPPLICATION_PASSWORD_ADMIN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 26:
		p.EnterOuterAlt(localctx, 26)
		{
			p.SetState(5527)
			p.Match(MySqlParserAUDIT_ABORT_EXEMPT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 27:
		p.EnterOuterAlt(localctx, 27)
		{
			p.SetState(5528)
			p.Match(MySqlParserAUDIT_ADMIN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 28:
		p.EnterOuterAlt(localctx, 28)
		{
			p.SetState(5529)
			p.Match(MySqlParserAUTHENTICATION_POLICY_ADMIN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 29:
		p.EnterOuterAlt(localctx, 29)
		{
			p.SetState(5530)
			p.Match(MySqlParserBACKUP_ADMIN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 30:
		p.EnterOuterAlt(localctx, 30)
		{
			p.SetState(5531)
			p.Match(MySqlParserBINLOG_ADMIN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 31:
		p.EnterOuterAlt(localctx, 31)
		{
			p.SetState(5532)
			p.Match(MySqlParserBINLOG_ENCRYPTION_ADMIN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 32:
		p.EnterOuterAlt(localctx, 32)
		{
			p.SetState(5533)
			p.Match(MySqlParserCLONE_ADMIN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 33:
		p.EnterOuterAlt(localctx, 33)
		{
			p.SetState(5534)
			p.Match(MySqlParserCONNECTION_ADMIN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 34:
		p.EnterOuterAlt(localctx, 34)
		{
			p.SetState(5535)
			p.Match(MySqlParserENCRYPTION_KEY_ADMIN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 35:
		p.EnterOuterAlt(localctx, 35)
		{
			p.SetState(5536)
			p.Match(MySqlParserFIREWALL_ADMIN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 36:
		p.EnterOuterAlt(localctx, 36)
		{
			p.SetState(5537)
			p.Match(MySqlParserFIREWALL_EXEMPT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 37:
		p.EnterOuterAlt(localctx, 37)
		{
			p.SetState(5538)
			p.Match(MySqlParserFIREWALL_USER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 38:
		p.EnterOuterAlt(localctx, 38)
		{
			p.SetState(5539)
			p.Match(MySqlParserFLUSH_OPTIMIZER_COSTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 39:
		p.EnterOuterAlt(localctx, 39)
		{
			p.SetState(5540)
			p.Match(MySqlParserFLUSH_STATUS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 40:
		p.EnterOuterAlt(localctx, 40)
		{
			p.SetState(5541)
			p.Match(MySqlParserFLUSH_TABLES)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 41:
		p.EnterOuterAlt(localctx, 41)
		{
			p.SetState(5542)
			p.Match(MySqlParserFLUSH_USER_RESOURCES)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 42:
		p.EnterOuterAlt(localctx, 42)
		{
			p.SetState(5543)
			p.Match(MySqlParserGROUP_REPLICATION_ADMIN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 43:
		p.EnterOuterAlt(localctx, 43)
		{
			p.SetState(5544)
			p.Match(MySqlParserINNODB_REDO_LOG_ARCHIVE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 44:
		p.EnterOuterAlt(localctx, 44)
		{
			p.SetState(5545)
			p.Match(MySqlParserINNODB_REDO_LOG_ENABLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 45:
		p.EnterOuterAlt(localctx, 45)
		{
			p.SetState(5546)
			p.Match(MySqlParserNDB_STORED_USER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 46:
		p.EnterOuterAlt(localctx, 46)
		{
			p.SetState(5547)
			p.Match(MySqlParserPASSWORDLESS_USER_ADMIN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 47:
		p.EnterOuterAlt(localctx, 47)
		{
			p.SetState(5548)
			p.Match(MySqlParserPERSIST_RO_VARIABLES_ADMIN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 48:
		p.EnterOuterAlt(localctx, 48)
		{
			p.SetState(5549)
			p.Match(MySqlParserREPLICATION_APPLIER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 49:
		p.EnterOuterAlt(localctx, 49)
		{
			p.SetState(5550)
			p.Match(MySqlParserREPLICATION_SLAVE_ADMIN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 50:
		p.EnterOuterAlt(localctx, 50)
		{
			p.SetState(5551)
			p.Match(MySqlParserRESOURCE_GROUP_ADMIN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 51:
		p.EnterOuterAlt(localctx, 51)
		{
			p.SetState(5552)
			p.Match(MySqlParserRESOURCE_GROUP_USER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 52:
		p.EnterOuterAlt(localctx, 52)
		{
			p.SetState(5553)
			p.Match(MySqlParserROLE_ADMIN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 53:
		p.EnterOuterAlt(localctx, 53)
		{
			p.SetState(5554)
			p.Match(MySqlParserSERVICE_CONNECTION_ADMIN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 54:
		p.EnterOuterAlt(localctx, 54)
		{
			p.SetState(5555)
			p.Match(MySqlParserSESSION_VARIABLES_ADMIN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 55:
		p.EnterOuterAlt(localctx, 55)
		{
			p.SetState(5556)
			p.Match(MySqlParserSET_USER_ID)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 56:
		p.EnterOuterAlt(localctx, 56)
		{
			p.SetState(5557)
			p.Match(MySqlParserSKIP_QUERY_REWRITE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 57:
		p.EnterOuterAlt(localctx, 57)
		{
			p.SetState(5558)
			p.Match(MySqlParserSHOW_ROUTINE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 58:
		p.EnterOuterAlt(localctx, 58)
		{
			p.SetState(5559)
			p.Match(MySqlParserSYSTEM_USER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 59:
		p.EnterOuterAlt(localctx, 59)
		{
			p.SetState(5560)
			p.Match(MySqlParserSYSTEM_VARIABLES_ADMIN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 60:
		p.EnterOuterAlt(localctx, 60)
		{
			p.SetState(5561)
			p.Match(MySqlParserTABLE_ENCRYPTION_ADMIN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 61:
		p.EnterOuterAlt(localctx, 61)
		{
			p.SetState(5562)
			p.Match(MySqlParserTP_CONNECTION_ADMIN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 62:
		p.EnterOuterAlt(localctx, 62)
		{
			p.SetState(5563)
			p.Match(MySqlParserVERSION_TOKEN_ADMIN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 63:
		p.EnterOuterAlt(localctx, 63)
		{
			p.SetState(5564)
			p.Match(MySqlParserXA_RECOVER_ADMIN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 64:
		p.EnterOuterAlt(localctx, 64)
		{
			p.SetState(5565)
			p.Match(MySqlParserLOAD)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5566)
			p.Match(MySqlParserFROM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5567)
			p.Match(MySqlParserS3)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 65:
		p.EnterOuterAlt(localctx, 65)
		{
			p.SetState(5568)
			p.Match(MySqlParserSELECT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5569)
			p.Match(MySqlParserINTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5570)
			p.Match(MySqlParserS3)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 66:
		p.EnterOuterAlt(localctx, 66)
		{
			p.SetState(5571)
			p.Match(MySqlParserINVOKE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5572)
			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)
	}
}

func (s *DefiniteSchemaPrivLevelContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitDefiniteSchemaPrivLevel(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *DefiniteFullTablePrivLevel2Context) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitDefiniteFullTablePrivLevel2(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *DefiniteFullTablePrivLevelContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitDefiniteFullTablePrivLevel(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *GlobalPrivLevelContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitGlobalPrivLevel(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *DefiniteTablePrivLevelContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitDefiniteTablePrivLevel(s)

	default:
		return t.VisitChildren(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 (s *CurrentSchemaPriviLevelContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCurrentSchemaPriviLevel(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *MySqlParser) PrivilegeLevel() (localctx IPrivilegeLevelContext) {
	localctx = NewPrivilegeLevelContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 466, MySqlParserRULE_privilegeLevel)
	p.SetState(5591)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 812, p.GetParserRuleContext()) {
	case 1:
		localctx = NewCurrentSchemaPriviLevelContext(p, localctx)
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5575)
			p.Match(MySqlParserSTAR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		localctx = NewGlobalPrivLevelContext(p, localctx)
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(5576)
			p.Match(MySqlParserSTAR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5577)
			p.Match(MySqlParserDOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5578)
			p.Match(MySqlParserSTAR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 3:
		localctx = NewDefiniteSchemaPrivLevelContext(p, localctx)
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(5579)
			p.Uid()
		}
		{
			p.SetState(5580)
			p.Match(MySqlParserDOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5581)
			p.Match(MySqlParserSTAR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 4:
		localctx = NewDefiniteFullTablePrivLevelContext(p, localctx)
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(5583)
			p.Uid()
		}
		{
			p.SetState(5584)
			p.Match(MySqlParserDOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5585)
			p.Uid()
		}

	case 5:
		localctx = NewDefiniteFullTablePrivLevel2Context(p, localctx)
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(5587)
			p.Uid()
		}
		{
			p.SetState(5588)
			p.DottedId()
		}

	case 6:
		localctx = NewDefiniteTablePrivLevelContext(p, localctx)
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(5590)
			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 (s *RenameUserClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitRenameUserClause(s)

	default:
		return t.VisitChildren(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(5593)

		var _x = p.UserName()

		localctx.(*RenameUserClauseContext).fromFirst = _x
	}
	{
		p.SetState(5594)
		p.Match(MySqlParserTO)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5595)

		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 (s *AnalyzeTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAnalyzeTable(s)

	default:
		return t.VisitChildren(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(5597)
		p.Match(MySqlParserANALYZE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(5599)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == MySqlParserNO_WRITE_TO_BINLOG || _la == MySqlParserLOCAL {
		{
			p.SetState(5598)

			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(5601)
		_la = p.GetTokenStream().LA(1)

		if !(_la == MySqlParserTABLE || _la == MySqlParserTABLES) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}
	{
		p.SetState(5602)
		p.Tables()
	}
	p.SetState(5620)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 816, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(5603)
			p.Match(MySqlParserUPDATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5604)
			p.Match(MySqlParserHISTOGRAM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5605)
			p.Match(MySqlParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5606)
			p.FullColumnName()
		}
		p.SetState(5611)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		for _la == MySqlParserCOMMA {
			{
				p.SetState(5607)
				p.Match(MySqlParserCOMMA)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(5608)
				p.FullColumnName()
			}

			p.SetState(5613)
			p.GetErrorHandler().Sync(p)
			if p.HasError() {
				goto errorExit
			}
			_la = p.GetTokenStream().LA(1)
		}
		p.SetState(5618)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 815, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(5614)
				p.Match(MySqlParserWITH)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(5615)
				p.DecimalLiteral()
			}
			{
				p.SetState(5616)
				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(5633)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 818, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(5622)
			p.Match(MySqlParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5623)
			p.Match(MySqlParserHISTOGRAM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5624)
			p.Match(MySqlParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5625)
			p.FullColumnName()
		}
		p.SetState(5630)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		for _la == MySqlParserCOMMA {
			{
				p.SetState(5626)
				p.Match(MySqlParserCOMMA)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(5627)
				p.FullColumnName()
			}

			p.SetState(5632)
			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 (s *CheckTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCheckTable(s)

	default:
		return t.VisitChildren(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(5635)
		p.Match(MySqlParserCHECK)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5636)
		p.Match(MySqlParserTABLE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5637)
		p.Tables()
	}
	p.SetState(5641)
	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(5638)
			p.CheckTableOption()
		}

		p.SetState(5643)
		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 (s *ChecksumTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitChecksumTable(s)

	default:
		return t.VisitChildren(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(5644)
		p.Match(MySqlParserCHECKSUM)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5645)
		p.Match(MySqlParserTABLE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5646)
		p.Tables()
	}
	p.SetState(5648)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == MySqlParserEXTENDED || _la == MySqlParserQUICK {
		{
			p.SetState(5647)

			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 (s *OptimizeTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitOptimizeTable(s)

	default:
		return t.VisitChildren(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(5650)
		p.Match(MySqlParserOPTIMIZE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(5652)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == MySqlParserNO_WRITE_TO_BINLOG || _la == MySqlParserLOCAL {
		{
			p.SetState(5651)

			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(5654)
		_la = p.GetTokenStream().LA(1)

		if !(_la == MySqlParserTABLE || _la == MySqlParserTABLES) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}
	{
		p.SetState(5655)
		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 (s *RepairTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitRepairTable(s)

	default:
		return t.VisitChildren(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(5657)
		p.Match(MySqlParserREPAIR)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(5659)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == MySqlParserNO_WRITE_TO_BINLOG || _la == MySqlParserLOCAL {
		{
			p.SetState(5658)

			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(5661)
		p.Match(MySqlParserTABLE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5662)
		p.Tables()
	}
	p.SetState(5664)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == MySqlParserQUICK {
		{
			p.SetState(5663)
			p.Match(MySqlParserQUICK)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	}
	p.SetState(5667)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == MySqlParserEXTENDED {
		{
			p.SetState(5666)
			p.Match(MySqlParserEXTENDED)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	}
	p.SetState(5670)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == MySqlParserUSE_FRM {
		{
			p.SetState(5669)
			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 (s *CheckTableOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCheckTableOption(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *MySqlParser) CheckTableOption() (localctx ICheckTableOptionContext) {
	localctx = NewCheckTableOptionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 480, MySqlParserRULE_checkTableOption)
	p.SetState(5679)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case MySqlParserFOR:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5672)
			p.Match(MySqlParserFOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5673)
			p.Match(MySqlParserUPGRADE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserQUICK:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(5674)
			p.Match(MySqlParserQUICK)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserFAST:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(5675)
			p.Match(MySqlParserFAST)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserMEDIUM:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(5676)
			p.Match(MySqlParserMEDIUM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserEXTENDED:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(5677)
			p.Match(MySqlParserEXTENDED)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserCHANGED:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(5678)
			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 (s *CreateUdfunctionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCreateUdfunction(s)

	default:
		return t.VisitChildren(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(5681)
		p.Match(MySqlParserCREATE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(5683)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == MySqlParserAGGREGATE {
		{
			p.SetState(5682)
			p.Match(MySqlParserAGGREGATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	}
	{
		p.SetState(5685)
		p.Match(MySqlParserFUNCTION)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(5687)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 828, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(5686)
			p.IfNotExists()
		}

	} else if p.HasError() { // JIM
		goto errorExit
	}
	{
		p.SetState(5689)
		p.Uid()
	}
	{
		p.SetState(5690)
		p.Match(MySqlParserRETURNS)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5691)

		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(5692)
		p.Match(MySqlParserSONAME)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5693)
		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 (s *InstallPluginContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitInstallPlugin(s)

	default:
		return t.VisitChildren(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(5695)
		p.Match(MySqlParserINSTALL)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5696)
		p.Match(MySqlParserPLUGIN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5697)
		p.Uid()
	}
	{
		p.SetState(5698)
		p.Match(MySqlParserSONAME)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5699)
		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 (s *UninstallPluginContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitUninstallPlugin(s)

	default:
		return t.VisitChildren(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(5701)
		p.Match(MySqlParserUNINSTALL)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5702)
		p.Match(MySqlParserPLUGIN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5703)
		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)
	}
}

func (s *SetTransactionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSetTransaction(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *SetCharsetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSetCharset(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *SetNamesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSetNames(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *SetPasswordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSetPassword(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *SetAutocommitContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSetAutocommit(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *SetNewValueInsideTriggerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSetNewValueInsideTrigger(s)

	default:
		return t.VisitChildren(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 (s *SetVariableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSetVariable(s)

	default:
		return t.VisitChildren(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(5757)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 836, p.GetParserRuleContext()) {
	case 1:
		localctx = NewSetVariableContext(p, localctx)
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5705)
			p.Match(MySqlParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5706)
			p.VariableClause()
		}
		{
			p.SetState(5707)
			_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(5710)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 829, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(5708)
				p.expression(0)
			}

		case 2:
			{
				p.SetState(5709)
				p.Match(MySqlParserON)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		case antlr.ATNInvalidAltNumber:
			goto errorExit
		}
		p.SetState(5721)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		for _la == MySqlParserCOMMA {
			{
				p.SetState(5712)
				p.Match(MySqlParserCOMMA)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(5713)
				p.VariableClause()
			}
			{
				p.SetState(5714)
				_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(5717)
			p.GetErrorHandler().Sync(p)
			if p.HasError() {
				goto errorExit
			}

			switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 830, p.GetParserRuleContext()) {
			case 1:
				{
					p.SetState(5715)
					p.expression(0)
				}

			case 2:
				{
					p.SetState(5716)
					p.Match(MySqlParserON)
					if p.HasError() {
						// Recognition error - abort rule
						goto errorExit
					}
				}

			case antlr.ATNInvalidAltNumber:
				goto errorExit
			}

			p.SetState(5723)
			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(5724)
			p.Match(MySqlParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5725)
			p.CharSet()
		}
		p.SetState(5728)
		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(5726)
				p.CharsetName()
			}

		case MySqlParserDEFAULT:
			{
				p.SetState(5727)
				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(5730)
			p.Match(MySqlParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5731)
			p.Match(MySqlParserNAMES)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(5738)
		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(5732)
				p.CharsetName()
			}
			p.SetState(5735)
			p.GetErrorHandler().Sync(p)
			if p.HasError() {
				goto errorExit
			}
			_la = p.GetTokenStream().LA(1)

			if _la == MySqlParserCOLLATE {
				{
					p.SetState(5733)
					p.Match(MySqlParserCOLLATE)
					if p.HasError() {
						// Recognition error - abort rule
						goto errorExit
					}
				}
				{
					p.SetState(5734)
					p.CollationName()
				}

			}

		case MySqlParserDEFAULT:
			{
				p.SetState(5737)
				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(5740)
			p.SetPasswordStatement()
		}

	case 5:
		localctx = NewSetTransactionContext(p, localctx)
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(5741)
			p.SetTransactionStatement()
		}

	case 6:
		localctx = NewSetAutocommitContext(p, localctx)
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(5742)
			p.SetAutocommitStatement()
		}

	case 7:
		localctx = NewSetNewValueInsideTriggerContext(p, localctx)
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(5743)
			p.Match(MySqlParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5744)
			p.FullId()
		}
		{
			p.SetState(5745)
			_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(5746)
			p.expression(0)
		}
		p.SetState(5754)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		for _la == MySqlParserCOMMA {
			{
				p.SetState(5747)
				p.Match(MySqlParserCOMMA)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(5748)
				p.FullId()
			}
			{
				p.SetState(5749)
				_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(5750)
				p.expression(0)
			}

			p.SetState(5756)
			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)
	}
}

func (s *ShowOpenTablesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitShowOpenTables(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *ShowGlobalInfoContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitShowGlobalInfo(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *ShowCreateFullIdObjectContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitShowCreateFullIdObject(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *ShowCreateUserContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitShowCreateUser(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *ShowErrorsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitShowErrors(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *ShowCountErrorsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitShowCountErrors(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *ShowObjectFilterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitShowObjectFilter(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *ShowCreateDbContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitShowCreateDb(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *ShowEngineContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitShowEngine(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *ShowSchemaFilterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitShowSchemaFilter(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *ShowIndexesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitShowIndexes(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *ShowLogEventsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitShowLogEvents(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *ShowMasterLogsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitShowMasterLogs(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *ShowGrantsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitShowGrants(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *ShowSlaveStatusContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitShowSlaveStatus(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *ShowRoutineContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitShowRoutine(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *ShowProfileContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitShowProfile(s)

	default:
		return t.VisitChildren(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 (s *ShowColumnsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitShowColumns(s)

	default:
		return t.VisitChildren(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(5912)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 859, p.GetParserRuleContext()) {
	case 1:
		localctx = NewShowMasterLogsContext(p, localctx)
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5759)
			p.Match(MySqlParserSHOW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5760)

			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(5761)
			p.Match(MySqlParserLOGS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		localctx = NewShowLogEventsContext(p, localctx)
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(5762)
			p.Match(MySqlParserSHOW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5763)

			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(5764)
			p.Match(MySqlParserEVENTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(5767)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserIN {
			{
				p.SetState(5765)
				p.Match(MySqlParserIN)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(5766)

				var _m = p.Match(MySqlParserSTRING_LITERAL)

				localctx.(*ShowLogEventsContext).filename = _m
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		}
		p.SetState(5771)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserFROM {
			{
				p.SetState(5769)
				p.Match(MySqlParserFROM)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(5770)

				var _x = p.DecimalLiteral()

				localctx.(*ShowLogEventsContext).fromPosition = _x
			}

		}
		p.SetState(5780)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserLIMIT {
			{
				p.SetState(5773)
				p.Match(MySqlParserLIMIT)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			p.SetState(5777)
			p.GetErrorHandler().Sync(p)

			if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 839, p.GetParserRuleContext()) == 1 {
				{
					p.SetState(5774)

					var _x = p.DecimalLiteral()

					localctx.(*ShowLogEventsContext).offset = _x
				}
				{
					p.SetState(5775)
					p.Match(MySqlParserCOMMA)
					if p.HasError() {
						// Recognition error - abort rule
						goto errorExit
					}
				}

			} else if p.HasError() { // JIM
				goto errorExit
			}
			{
				p.SetState(5779)

				var _x = p.DecimalLiteral()

				localctx.(*ShowLogEventsContext).rowCount = _x
			}

		}

	case 3:
		localctx = NewShowObjectFilterContext(p, localctx)
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(5782)
			p.Match(MySqlParserSHOW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5783)
			p.ShowCommonEntity()
		}
		p.SetState(5785)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserLIKE || _la == MySqlParserWHERE {
			{
				p.SetState(5784)
				p.ShowFilter()
			}

		}

	case 4:
		localctx = NewShowColumnsContext(p, localctx)
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(5787)
			p.Match(MySqlParserSHOW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(5789)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserFULL {
			{
				p.SetState(5788)
				p.Match(MySqlParserFULL)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		}
		{
			p.SetState(5791)

			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(5792)

			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(5793)
			p.TableName()
		}
		p.SetState(5796)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserFROM || _la == MySqlParserIN {
			{
				p.SetState(5794)

				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(5795)
				p.Uid()
			}

		}
		p.SetState(5799)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserLIKE || _la == MySqlParserWHERE {
			{
				p.SetState(5798)
				p.ShowFilter()
			}

		}

	case 5:
		localctx = NewShowCreateDbContext(p, localctx)
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(5801)
			p.Match(MySqlParserSHOW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5802)
			p.Match(MySqlParserCREATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5803)

			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(5805)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 845, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(5804)
				p.IfNotExists()
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}
		{
			p.SetState(5807)
			p.Uid()
		}

	case 6:
		localctx = NewShowCreateFullIdObjectContext(p, localctx)
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(5808)
			p.Match(MySqlParserSHOW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5809)
			p.Match(MySqlParserCREATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5810)

			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(5811)
			p.FullId()
		}

	case 7:
		localctx = NewShowCreateUserContext(p, localctx)
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(5812)
			p.Match(MySqlParserSHOW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5813)
			p.Match(MySqlParserCREATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5814)
			p.Match(MySqlParserUSER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5815)
			p.UserName()
		}

	case 8:
		localctx = NewShowEngineContext(p, localctx)
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(5816)
			p.Match(MySqlParserSHOW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5817)
			p.Match(MySqlParserENGINE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5818)
			p.EngineName()
		}
		{
			p.SetState(5819)

			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(5821)
			p.Match(MySqlParserSHOW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5822)
			p.ShowGlobalInfoClause()
		}

	case 10:
		localctx = NewShowErrorsContext(p, localctx)
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(5823)
			p.Match(MySqlParserSHOW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5824)

			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(5832)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserLIMIT {
			{
				p.SetState(5825)
				p.Match(MySqlParserLIMIT)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			p.SetState(5829)
			p.GetErrorHandler().Sync(p)

			if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 846, p.GetParserRuleContext()) == 1 {
				{
					p.SetState(5826)

					var _x = p.DecimalLiteral()

					localctx.(*ShowErrorsContext).offset = _x
				}
				{
					p.SetState(5827)
					p.Match(MySqlParserCOMMA)
					if p.HasError() {
						// Recognition error - abort rule
						goto errorExit
					}
				}

			} else if p.HasError() { // JIM
				goto errorExit
			}
			{
				p.SetState(5831)

				var _x = p.DecimalLiteral()

				localctx.(*ShowErrorsContext).rowCount = _x
			}

		}

	case 11:
		localctx = NewShowCountErrorsContext(p, localctx)
		p.EnterOuterAlt(localctx, 11)
		{
			p.SetState(5834)
			p.Match(MySqlParserSHOW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5835)
			p.Match(MySqlParserCOUNT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5836)
			p.Match(MySqlParserLR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5837)
			p.Match(MySqlParserSTAR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5838)
			p.Match(MySqlParserRR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5839)

			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(5840)
			p.Match(MySqlParserSHOW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5841)
			p.ShowSchemaEntity()
		}
		p.SetState(5844)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserFROM || _la == MySqlParserIN {
			{
				p.SetState(5842)

				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(5843)
				p.Uid()
			}

		}
		p.SetState(5847)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserLIKE || _la == MySqlParserWHERE {
			{
				p.SetState(5846)
				p.ShowFilter()
			}

		}

	case 13:
		localctx = NewShowRoutineContext(p, localctx)
		p.EnterOuterAlt(localctx, 13)
		{
			p.SetState(5849)
			p.Match(MySqlParserSHOW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5850)

			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(5851)
			p.Match(MySqlParserCODE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5852)
			p.FullId()
		}

	case 14:
		localctx = NewShowGrantsContext(p, localctx)
		p.EnterOuterAlt(localctx, 14)
		{
			p.SetState(5853)
			p.Match(MySqlParserSHOW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5854)
			p.Match(MySqlParserGRANTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(5857)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserFOR {
			{
				p.SetState(5855)
				p.Match(MySqlParserFOR)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(5856)
				p.UserName()
			}

		}

	case 15:
		localctx = NewShowIndexesContext(p, localctx)
		p.EnterOuterAlt(localctx, 15)
		{
			p.SetState(5859)
			p.Match(MySqlParserSHOW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5860)

			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(5861)

			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(5862)
			p.TableName()
		}
		p.SetState(5865)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserFROM || _la == MySqlParserIN {
			{
				p.SetState(5863)

				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(5864)
				p.Uid()
			}

		}
		p.SetState(5869)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserWHERE {
			{
				p.SetState(5867)
				p.Match(MySqlParserWHERE)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(5868)
				p.expression(0)
			}

		}

	case 16:
		localctx = NewShowOpenTablesContext(p, localctx)
		p.EnterOuterAlt(localctx, 16)
		{
			p.SetState(5871)
			p.Match(MySqlParserSHOW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5872)
			p.Match(MySqlParserOPEN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5873)
			p.Match(MySqlParserTABLES)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(5876)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserFROM || _la == MySqlParserIN {
			{
				p.SetState(5874)

				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(5875)
				p.Uid()
			}

		}
		p.SetState(5879)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserLIKE || _la == MySqlParserWHERE {
			{
				p.SetState(5878)
				p.ShowFilter()
			}

		}

	case 17:
		localctx = NewShowProfileContext(p, localctx)
		p.EnterOuterAlt(localctx, 17)
		{
			p.SetState(5881)
			p.Match(MySqlParserSHOW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5882)
			p.Match(MySqlParserPROFILE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5883)
			p.ShowProfileType()
		}
		p.SetState(5888)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		for _la == MySqlParserCOMMA {
			{
				p.SetState(5884)
				p.Match(MySqlParserCOMMA)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(5885)
				p.ShowProfileType()
			}

			p.SetState(5890)
			p.GetErrorHandler().Sync(p)
			if p.HasError() {
				goto errorExit
			}
			_la = p.GetTokenStream().LA(1)
		}
		p.SetState(5894)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserFOR {
			{
				p.SetState(5891)
				p.Match(MySqlParserFOR)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(5892)
				p.Match(MySqlParserQUERY)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(5893)

				var _x = p.DecimalLiteral()

				localctx.(*ShowProfileContext).queryCount = _x
			}

		}

		{
			p.SetState(5896)
			p.Match(MySqlParserLIMIT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(5900)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 857, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(5897)

				var _x = p.DecimalLiteral()

				localctx.(*ShowProfileContext).offset = _x
			}
			{
				p.SetState(5898)
				p.Match(MySqlParserCOMMA)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}
		{
			p.SetState(5902)

			var _x = p.DecimalLiteral()

			localctx.(*ShowProfileContext).rowCount = _x
		}

	case 18:
		localctx = NewShowSlaveStatusContext(p, localctx)
		p.EnterOuterAlt(localctx, 18)
		{
			p.SetState(5904)
			p.Match(MySqlParserSHOW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5905)
			p.Match(MySqlParserSLAVE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5906)
			p.Match(MySqlParserSTATUS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(5910)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserFOR {
			{
				p.SetState(5907)
				p.Match(MySqlParserFOR)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(5908)
				p.Match(MySqlParserCHANNEL)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(5909)
				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 (s *VariableClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitVariableClause(s)

	default:
		return t.VisitChildren(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(5924)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case MySqlParserLOCAL_ID:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5914)
			p.Match(MySqlParserLOCAL_ID)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserGLOBAL_ID:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(5915)
			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, 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, 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, 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(5921)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 861, p.GetParserRuleContext()) == 1 {
			p.SetState(5918)
			p.GetErrorHandler().Sync(p)
			if p.HasError() {
				goto errorExit
			}
			_la = p.GetTokenStream().LA(1)

			if _la == MySqlParserAT_SIGN {
				{
					p.SetState(5916)
					p.Match(MySqlParserAT_SIGN)
					if p.HasError() {
						// Recognition error - abort rule
						goto errorExit
					}
				}
				{
					p.SetState(5917)
					p.Match(MySqlParserAT_SIGN)
					if p.HasError() {
						// Recognition error - abort rule
						goto errorExit
					}
				}

			}
			{
				p.SetState(5920)
				_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(5923)
			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 (s *ShowCommonEntityContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitShowCommonEntity(s)

	default:
		return t.VisitChildren(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(5939)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case MySqlParserCHARACTER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5926)
			p.Match(MySqlParserCHARACTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5927)
			p.Match(MySqlParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserCOLLATION:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(5928)
			p.Match(MySqlParserCOLLATION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserDATABASES:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(5929)
			p.Match(MySqlParserDATABASES)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserSCHEMAS:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(5930)
			p.Match(MySqlParserSCHEMAS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserFUNCTION:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(5931)
			p.Match(MySqlParserFUNCTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5932)
			p.Match(MySqlParserSTATUS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserPROCEDURE:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(5933)
			p.Match(MySqlParserPROCEDURE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5934)
			p.Match(MySqlParserSTATUS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserGLOBAL, MySqlParserSESSION, MySqlParserSTATUS, MySqlParserVARIABLES:
		p.EnterOuterAlt(localctx, 7)
		p.SetState(5936)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserGLOBAL || _la == MySqlParserSESSION {
			{
				p.SetState(5935)
				_la = p.GetTokenStream().LA(1)

				if !(_la == MySqlParserGLOBAL || _la == MySqlParserSESSION) {
					p.GetErrorHandler().RecoverInline(p)
				} else {
					p.GetErrorHandler().ReportMatch(p)
					p.Consume()
				}
			}

		}
		{
			p.SetState(5938)
			_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 (s *ShowFilterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitShowFilter(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *MySqlParser) ShowFilter() (localctx IShowFilterContext) {
	localctx = NewShowFilterContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 496, MySqlParserRULE_showFilter)
	p.SetState(5945)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case MySqlParserLIKE:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5941)
			p.Match(MySqlParserLIKE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5942)
			p.Match(MySqlParserSTRING_LITERAL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserWHERE:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(5943)
			p.Match(MySqlParserWHERE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5944)
			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 (s *ShowGlobalInfoClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitShowGlobalInfoClause(s)

	default:
		return t.VisitChildren(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(5964)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case MySqlParserENGINES, MySqlParserSTORAGE:
		p.EnterOuterAlt(localctx, 1)
		p.SetState(5948)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserSTORAGE {
			{
				p.SetState(5947)
				p.Match(MySqlParserSTORAGE)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		}
		{
			p.SetState(5950)
			p.Match(MySqlParserENGINES)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserMASTER:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(5951)
			p.Match(MySqlParserMASTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5952)
			p.Match(MySqlParserSTATUS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserPLUGINS:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(5953)
			p.Match(MySqlParserPLUGINS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserPRIVILEGES:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(5954)
			p.Match(MySqlParserPRIVILEGES)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserFULL, MySqlParserPROCESSLIST:
		p.EnterOuterAlt(localctx, 5)
		p.SetState(5956)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserFULL {
			{
				p.SetState(5955)
				p.Match(MySqlParserFULL)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		}
		{
			p.SetState(5958)
			p.Match(MySqlParserPROCESSLIST)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserPROFILES:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(5959)
			p.Match(MySqlParserPROFILES)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserSLAVE:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(5960)
			p.Match(MySqlParserSLAVE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5961)
			p.Match(MySqlParserHOSTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserAUTHORS:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(5962)
			p.Match(MySqlParserAUTHORS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserCONTRIBUTORS:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(5963)
			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 (s *ShowSchemaEntityContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitShowSchemaEntity(s)

	default:
		return t.VisitChildren(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(5974)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case MySqlParserEVENTS:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5966)
			p.Match(MySqlParserEVENTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserTABLE:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(5967)
			p.Match(MySqlParserTABLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5968)
			p.Match(MySqlParserSTATUS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserFULL, MySqlParserTABLES:
		p.EnterOuterAlt(localctx, 3)
		p.SetState(5970)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserFULL {
			{
				p.SetState(5969)
				p.Match(MySqlParserFULL)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		}
		{
			p.SetState(5972)
			p.Match(MySqlParserTABLES)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserTRIGGERS:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(5973)
			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 (s *ShowProfileTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitShowProfileType(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *MySqlParser) ShowProfileType() (localctx IShowProfileTypeContext) {
	localctx = NewShowProfileTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 502, MySqlParserRULE_showProfileType)
	p.SetState(5988)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case MySqlParserALL:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5976)
			p.Match(MySqlParserALL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserBLOCK:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(5977)
			p.Match(MySqlParserBLOCK)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5978)
			p.Match(MySqlParserIO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserCONTEXT:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(5979)
			p.Match(MySqlParserCONTEXT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5980)
			p.Match(MySqlParserSWITCHES)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserCPU:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(5981)
			p.Match(MySqlParserCPU)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserIPC:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(5982)
			p.Match(MySqlParserIPC)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserMEMORY:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(5983)
			p.Match(MySqlParserMEMORY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserPAGE:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(5984)
			p.Match(MySqlParserPAGE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5985)
			p.Match(MySqlParserFAULTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserSOURCE:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(5986)
			p.Match(MySqlParserSOURCE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserSWAPS:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(5987)
			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 (s *BinlogStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitBinlogStatement(s)

	default:
		return t.VisitChildren(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(5990)
		p.Match(MySqlParserBINLOG)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5991)
		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 (s *CacheIndexStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCacheIndexStatement(s)

	default:
		return t.VisitChildren(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(5993)
		p.Match(MySqlParserCACHE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5994)
		p.Match(MySqlParserINDEX)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5995)
		p.TableIndexes()
	}
	p.SetState(6000)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == MySqlParserCOMMA {
		{
			p.SetState(5996)
			p.Match(MySqlParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5997)
			p.TableIndexes()
		}

		p.SetState(6002)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}
	p.SetState(6010)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == MySqlParserPARTITION {
		{
			p.SetState(6003)
			p.Match(MySqlParserPARTITION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6004)
			p.Match(MySqlParserLR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(6007)
		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, 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, 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, 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(6005)
				p.UidList()
			}

		case MySqlParserALL:
			{
				p.SetState(6006)
				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(6009)
			p.Match(MySqlParserRR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	}
	{
		p.SetState(6012)
		p.Match(MySqlParserIN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(6013)

		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 (s *FlushStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitFlushStatement(s)

	default:
		return t.VisitChildren(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(6015)
		p.Match(MySqlParserFLUSH)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(6017)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == MySqlParserNO_WRITE_TO_BINLOG || _la == MySqlParserLOCAL {
		{
			p.SetState(6016)

			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(6019)
		p.FlushOption()
	}
	p.SetState(6024)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == MySqlParserCOMMA {
		{
			p.SetState(6020)
			p.Match(MySqlParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6021)
			p.FlushOption()
		}

		p.SetState(6026)
		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 (s *KillStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitKillStatement(s)

	default:
		return t.VisitChildren(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(6027)
		p.Match(MySqlParserKILL)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(6029)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 877, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(6028)

			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(6031)
		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 (s *LoadIndexIntoCacheContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitLoadIndexIntoCache(s)

	default:
		return t.VisitChildren(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(6033)
		p.Match(MySqlParserLOAD)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(6034)
		p.Match(MySqlParserINDEX)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(6035)
		p.Match(MySqlParserINTO)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(6036)
		p.Match(MySqlParserCACHE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(6037)
		p.LoadedTableIndexes()
	}
	p.SetState(6042)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == MySqlParserCOMMA {
		{
			p.SetState(6038)
			p.Match(MySqlParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6039)
			p.LoadedTableIndexes()
		}

		p.SetState(6044)
		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 (s *ResetStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitResetStatement(s)

	default:
		return t.VisitChildren(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(6045)
		p.Match(MySqlParserRESET)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(6046)
		p.Match(MySqlParserQUERY)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(6047)
		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 (s *ShutdownStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitShutdownStatement(s)

	default:
		return t.VisitChildren(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(6049)
		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 (s *TableIndexesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTableIndexes(s)

	default:
		return t.VisitChildren(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(6051)
		p.TableName()
	}
	p.SetState(6059)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == MySqlParserINDEX || _la == MySqlParserKEY || _la == MySqlParserLR_BRACKET {
		p.SetState(6053)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserINDEX || _la == MySqlParserKEY {
			{
				p.SetState(6052)

				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(6055)
			p.Match(MySqlParserLR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6056)
			p.UidList()
		}
		{
			p.SetState(6057)
			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)
	}
}

func (s *TableFlushOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTableFlushOption(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *ChannelFlushOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitChannelFlushOption(s)

	default:
		return t.VisitChildren(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 (s *SimpleFlushOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSimpleFlushOption(s)

	default:
		return t.VisitChildren(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(6093)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 887, p.GetParserRuleContext()) {
	case 1:
		localctx = NewSimpleFlushOptionContext(p, localctx)
		p.EnterOuterAlt(localctx, 1)
		p.SetState(6079)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetTokenStream().LA(1) {
		case MySqlParserDES_KEY_FILE:
			{
				p.SetState(6061)
				p.Match(MySqlParserDES_KEY_FILE)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		case MySqlParserHOSTS:
			{
				p.SetState(6062)
				p.Match(MySqlParserHOSTS)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		case MySqlParserBINARY, MySqlParserENGINE, MySqlParserERROR, MySqlParserGENERAL, MySqlParserLOGS, MySqlParserRELAY, MySqlParserSLOW:
			p.SetState(6064)
			p.GetErrorHandler().Sync(p)
			if p.HasError() {
				goto errorExit
			}
			_la = p.GetTokenStream().LA(1)

			if _la == MySqlParserBINARY || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&536870917) != 0) || _la == MySqlParserRELAY || _la == MySqlParserSLOW {
				{
					p.SetState(6063)
					_la = p.GetTokenStream().LA(1)

					if !(_la == MySqlParserBINARY || ((int64((_la-409)) & ^0x3f) == 0 && ((int64(1)<<(_la-409))&536870917) != 0) || _la == MySqlParserRELAY || _la == MySqlParserSLOW) {
						p.GetErrorHandler().RecoverInline(p)
					} else {
						p.GetErrorHandler().ReportMatch(p)
						p.Consume()
					}
				}

			}
			{
				p.SetState(6066)
				p.Match(MySqlParserLOGS)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		case MySqlParserOPTIMIZER_COSTS:
			{
				p.SetState(6067)
				p.Match(MySqlParserOPTIMIZER_COSTS)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		case MySqlParserPRIVILEGES:
			{
				p.SetState(6068)
				p.Match(MySqlParserPRIVILEGES)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		case MySqlParserQUERY:
			{
				p.SetState(6069)
				p.Match(MySqlParserQUERY)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(6070)
				p.Match(MySqlParserCACHE)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		case MySqlParserSTATUS:
			{
				p.SetState(6071)
				p.Match(MySqlParserSTATUS)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		case MySqlParserUSER_RESOURCES:
			{
				p.SetState(6072)
				p.Match(MySqlParserUSER_RESOURCES)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		case MySqlParserTABLES:
			{
				p.SetState(6073)
				p.Match(MySqlParserTABLES)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			p.SetState(6077)
			p.GetErrorHandler().Sync(p)

			if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 882, p.GetParserRuleContext()) == 1 {
				{
					p.SetState(6074)
					p.Match(MySqlParserWITH)
					if p.HasError() {
						// Recognition error - abort rule
						goto errorExit
					}
				}
				{
					p.SetState(6075)
					p.Match(MySqlParserREAD)
					if p.HasError() {
						// Recognition error - abort rule
						goto errorExit
					}
				}
				{
					p.SetState(6076)
					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(6081)
			p.Match(MySqlParserRELAY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6082)
			p.Match(MySqlParserLOGS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(6084)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserFOR {
			{
				p.SetState(6083)
				p.ChannelOption()
			}

		}

	case 3:
		localctx = NewTableFlushOptionContext(p, localctx)
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(6086)
			_la = p.GetTokenStream().LA(1)

			if !(_la == MySqlParserTABLE || _la == MySqlParserTABLES) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		p.SetState(6088)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 885, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(6087)
				p.Tables()
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}
		p.SetState(6091)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 886, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(6090)
				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 (s *FlushTableOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitFlushTableOption(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *MySqlParser) FlushTableOption() (localctx IFlushTableOptionContext) {
	localctx = NewFlushTableOptionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 522, MySqlParserRULE_flushTableOption)
	p.SetState(6100)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case MySqlParserWITH:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(6095)
			p.Match(MySqlParserWITH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6096)
			p.Match(MySqlParserREAD)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6097)
			p.Match(MySqlParserLOCK)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserFOR:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(6098)
			p.Match(MySqlParserFOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6099)
			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 (s *LoadedTableIndexesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitLoadedTableIndexes(s)

	default:
		return t.VisitChildren(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(6102)
		p.TableName()
	}
	p.SetState(6110)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == MySqlParserPARTITION {
		{
			p.SetState(6103)
			p.Match(MySqlParserPARTITION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6104)
			p.Match(MySqlParserLR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(6107)
		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, 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, 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, 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(6105)

				var _x = p.UidList()

				localctx.(*LoadedTableIndexesContext).partitionList = _x
			}

		case MySqlParserALL:
			{
				p.SetState(6106)
				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(6109)
			p.Match(MySqlParserRR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	}
	p.SetState(6119)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 892, p.GetParserRuleContext()) == 1 {
		p.SetState(6113)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserINDEX || _la == MySqlParserKEY {
			{
				p.SetState(6112)

				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(6115)
			p.Match(MySqlParserLR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6116)

			var _x = p.UidList()

			localctx.(*LoadedTableIndexesContext).indexList = _x
		}
		{
			p.SetState(6117)
			p.Match(MySqlParserRR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	} else if p.HasError() { // JIM
		goto errorExit
	}
	p.SetState(6123)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == MySqlParserIGNORE {
		{
			p.SetState(6121)
			p.Match(MySqlParserIGNORE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6122)
			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 (s *SimpleDescribeStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSimpleDescribeStatement(s)

	default:
		return t.VisitChildren(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(6125)

		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(6126)
		p.TableName()
	}
	p.SetState(6129)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 894, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(6127)

			var _x = p.Uid()

			localctx.(*SimpleDescribeStatementContext).column = _x
		}

	} else if p.HasError() { // JIM
		goto errorExit
	} else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 894, p.GetParserRuleContext()) == 2 {
		{
			p.SetState(6128)

			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 (s *FullDescribeStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitFullDescribeStatement(s)

	default:
		return t.VisitChildren(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(6131)

		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(6135)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == MySqlParserEXTENDED || _la == MySqlParserPARTITIONS || _la == MySqlParserFORMAT {
		{
			p.SetState(6132)

			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(6133)
			p.Match(MySqlParserEQUAL_SYMBOL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6134)

			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(6137)
		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 (s *HelpStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitHelpStatement(s)

	default:
		return t.VisitChildren(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(6139)
		p.Match(MySqlParserHELP)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(6140)
		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 (s *UseStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitUseStatement(s)

	default:
		return t.VisitChildren(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(6142)
		p.Match(MySqlParserUSE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(6143)
		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 (s *SignalStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSignalStatement(s)

	default:
		return t.VisitChildren(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(6145)
		p.Match(MySqlParserSIGNAL)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(6153)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case MySqlParserSQLSTATE:
		{
			p.SetState(6146)
			p.Match(MySqlParserSQLSTATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(6148)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserVALUE {
			{
				p.SetState(6147)
				p.Match(MySqlParserVALUE)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		}
		{
			p.SetState(6150)
			p.StringLiteral()
		}

	case MySqlParserID:
		{
			p.SetState(6151)
			p.Match(MySqlParserID)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserREVERSE_QUOTE_ID:
		{
			p.SetState(6152)
			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(6164)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 899, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(6155)
			p.Match(MySqlParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6156)
			p.SignalConditionInformation()
		}
		p.SetState(6161)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		for _la == MySqlParserCOMMA {
			{
				p.SetState(6157)
				p.Match(MySqlParserCOMMA)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(6158)
				p.SignalConditionInformation()
			}

			p.SetState(6163)
			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 (s *ResignalStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitResignalStatement(s)

	default:
		return t.VisitChildren(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(6166)
		p.Match(MySqlParserRESIGNAL)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(6174)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	switch p.GetTokenStream().LA(1) {
	case MySqlParserSQLSTATE:
		{
			p.SetState(6167)
			p.Match(MySqlParserSQLSTATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(6169)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserVALUE {
			{
				p.SetState(6168)
				p.Match(MySqlParserVALUE)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		}
		{
			p.SetState(6171)
			p.StringLiteral()
		}

	case MySqlParserID:
		{
			p.SetState(6172)
			p.Match(MySqlParserID)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserREVERSE_QUOTE_ID:
		{
			p.SetState(6173)
			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(6185)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 903, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(6176)
			p.Match(MySqlParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6177)
			p.SignalConditionInformation()
		}
		p.SetState(6182)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		for _la == MySqlParserCOMMA {
			{
				p.SetState(6178)
				p.Match(MySqlParserCOMMA)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(6179)
				p.SignalConditionInformation()
			}

			p.SetState(6184)
			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 (s *SignalConditionInformationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSignalConditionInformation(s)

	default:
		return t.VisitChildren(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(6187)
		_la = p.GetTokenStream().LA(1)

		if !(((int64((_la-359)) & ^0x3f) == 0 && ((int64(1)<<(_la-359))&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(6188)
		p.Match(MySqlParserEQUAL_SYMBOL)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(6193)
	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(6189)
			p.StringLiteral()
		}

	case MySqlParserDECIMAL_LITERAL:
		{
			p.SetState(6190)
			p.Match(MySqlParserDECIMAL_LITERAL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserLOCAL_ID, MySqlParserGLOBAL_ID:
		{
			p.SetState(6191)
			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, 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, 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, MySqlParserVERSION, MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS, MySqlParserWEEKDAY, MySqlParserWEEKOFYEAR, MySqlParserWEIGHT_STRING, MySqlParserWITHIN, MySqlParserYEARWEEK, MySqlParserY_FUNCTION, MySqlParserX_FUNCTION, MySqlParserMOD, MySqlParserID:
		{
			p.SetState(6192)
			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 (s *WithStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitWithStatement(s)

	default:
		return t.VisitChildren(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(6195)
		p.Match(MySqlParserWITH)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(6197)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 905, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(6196)
			p.Match(MySqlParserRECURSIVE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	} else if p.HasError() { // JIM
		goto errorExit
	}
	{
		p.SetState(6199)
		p.CommonTableExpressions()
	}
	p.SetState(6204)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == MySqlParserCOMMA {
		{
			p.SetState(6200)
			p.Match(MySqlParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6201)
			p.CommonTableExpressions()
		}

		p.SetState(6206)
		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 (s *TableStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTableStatement(s)

	default:
		return t.VisitChildren(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(6207)
		p.Match(MySqlParserTABLE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(6208)
		p.TableName()
	}
	p.SetState(6210)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == MySqlParserORDER {
		{
			p.SetState(6209)
			p.OrderByClause()
		}

	}
	p.SetState(6213)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == MySqlParserLIMIT {
		{
			p.SetState(6212)
			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 (s *DiagnosticsStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitDiagnosticsStatement(s)

	default:
		return t.VisitChildren(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(6215)
		p.Match(MySqlParserGET)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(6217)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == MySqlParserCURRENT || _la == MySqlParserSTACKED {
		{
			p.SetState(6216)
			_la = p.GetTokenStream().LA(1)

			if !(_la == MySqlParserCURRENT || _la == MySqlParserSTACKED) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}

	}
	{
		p.SetState(6219)
		p.Match(MySqlParserDIAGNOSTICS)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(6251)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 913, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(6220)
			p.VariableClause()
		}
		{
			p.SetState(6221)
			p.Match(MySqlParserEQUAL_SYMBOL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6222)
			_la = p.GetTokenStream().LA(1)

			if !(_la == MySqlParserNUMBER || _la == MySqlParserROW_COUNT) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		p.SetState(6230)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		for _la == MySqlParserCOMMA {
			{
				p.SetState(6223)
				p.Match(MySqlParserCOMMA)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(6224)
				p.VariableClause()
			}
			{
				p.SetState(6225)
				p.Match(MySqlParserEQUAL_SYMBOL)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(6226)
				_la = p.GetTokenStream().LA(1)

				if !(_la == MySqlParserNUMBER || _la == MySqlParserROW_COUNT) {
					p.GetErrorHandler().RecoverInline(p)
				} else {
					p.GetErrorHandler().ReportMatch(p)
					p.Consume()
				}
			}

			p.SetState(6232)
			p.GetErrorHandler().Sync(p)
			if p.HasError() {
				goto errorExit
			}
			_la = p.GetTokenStream().LA(1)
		}

	case 2:
		{
			p.SetState(6233)
			p.Match(MySqlParserCONDITION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(6236)
		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(6234)
				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, 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, 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, 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(6235)
				p.VariableClause()
			}

		default:
			p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
			goto errorExit
		}
		{
			p.SetState(6238)
			p.VariableClause()
		}
		{
			p.SetState(6239)
			p.Match(MySqlParserEQUAL_SYMBOL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6240)
			p.DiagnosticsConditionInformationName()
		}
		p.SetState(6248)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		for _la == MySqlParserCOMMA {
			{
				p.SetState(6241)
				p.Match(MySqlParserCOMMA)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(6242)
				p.VariableClause()
			}
			{
				p.SetState(6243)
				p.Match(MySqlParserEQUAL_SYMBOL)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(6244)
				p.DiagnosticsConditionInformationName()
			}

			p.SetState(6250)
			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 (s *DiagnosticsConditionInformationNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitDiagnosticsConditionInformationName(s)

	default:
		return t.VisitChildren(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(6253)
		_la = p.GetTokenStream().LA(1)

		if !(((int64((_la-359)) & ^0x3f) == 0 && ((int64(1)<<(_la-359))&272105729) != 0) || _la == MySqlParserMESSAGE_TEXT || _la == MySqlParserMYSQL_ERRNO || ((int64((_la-592)) & ^0x3f) == 0 && ((int64(1)<<(_la-592))&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)
	}
}

func (s *DescribeStatementsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitDescribeStatements(s)

	default:
		return t.VisitChildren(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 (s *DescribeConnectionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitDescribeConnection(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *MySqlParser) DescribeObjectClause() (localctx IDescribeObjectClauseContext) {
	localctx = NewDescribeObjectClauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 548, MySqlParserRULE_describeObjectClause)
	p.SetState(6265)
	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(6260)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetTokenStream().LA(1) {
		case MySqlParserSELECT, MySqlParserLR_BRACKET:
			{
				p.SetState(6255)
				p.SelectStatement()
			}

		case MySqlParserDELETE:
			{
				p.SetState(6256)
				p.DeleteStatement()
			}

		case MySqlParserINSERT:
			{
				p.SetState(6257)
				p.InsertStatement()
			}

		case MySqlParserREPLACE:
			{
				p.SetState(6258)
				p.ReplaceStatement()
			}

		case MySqlParserUPDATE:
			{
				p.SetState(6259)
				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(6262)
			p.Match(MySqlParserFOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6263)
			p.Match(MySqlParserCONNECTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6264)
			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 (s *FullIdContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitFullId(s)

	default:
		return t.VisitChildren(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(6267)
		p.Uid()
	}
	p.SetState(6271)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 916, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(6268)
			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(), 916, p.GetParserRuleContext()) == 2 {
		{
			p.SetState(6269)
			p.Match(MySqlParserDOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6270)
			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 (s *TableNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTableName(s)

	default:
		return t.VisitChildren(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(6273)
		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 (s *RoleNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitRoleName(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *MySqlParser) RoleName() (localctx IRoleNameContext) {
	localctx = NewRoleNameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 554, MySqlParserRULE_roleName)
	p.SetState(6277)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 917, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(6275)
			p.UserName()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(6276)
			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 (s *FullColumnNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitFullColumnName(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *MySqlParser) FullColumnName() (localctx IFullColumnNameContext) {
	localctx = NewFullColumnNameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 556, MySqlParserRULE_fullColumnName)
	p.SetState(6293)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 922, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(6279)
			p.Uid()
		}
		p.SetState(6284)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 919, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(6280)
				p.DottedId()
			}
			p.SetState(6282)
			p.GetErrorHandler().Sync(p)

			if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 918, p.GetParserRuleContext()) == 1 {
				{
					p.SetState(6281)
					p.DottedId()
				}

			} else if p.HasError() { // JIM
				goto errorExit
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		p.SetState(6287)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 920, p.GetParserRuleContext()) == 1 {
			p.SetState(6286)
			p.MatchWildcard()

		} else if p.HasError() { // JIM
			goto errorExit
		}
		{
			p.SetState(6289)
			p.DottedId()
		}
		p.SetState(6291)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 921, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(6290)
				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 (s *IndexColumnNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitIndexColumnName(s)

	default:
		return t.VisitChildren(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(6306)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 925, p.GetParserRuleContext()) {
	case 1:
		p.SetState(6297)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 923, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(6295)
				p.Uid()
			}

		case 2:
			{
				p.SetState(6296)
				p.Match(MySqlParserSTRING_LITERAL)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		case antlr.ATNInvalidAltNumber:
			goto errorExit
		}
		p.SetState(6303)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserLR_BRACKET {
			{
				p.SetState(6299)
				p.Match(MySqlParserLR_BRACKET)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(6300)
				p.DecimalLiteral()
			}
			{
				p.SetState(6301)
				p.Match(MySqlParserRR_BRACKET)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		}

	case 2:
		{
			p.SetState(6305)
			p.expression(0)
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}
	p.SetState(6309)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == MySqlParserASC || _la == MySqlParserDESC {
		{
			p.SetState(6308)

			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 (s *SimpleUserNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSimpleUserName(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *MySqlParser) SimpleUserName() (localctx ISimpleUserNameContext) {
	localctx = NewSimpleUserNameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 560, MySqlParserRULE_simpleUserName)
	p.SetState(6315)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 927, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(6311)
			p.Match(MySqlParserSTRING_LITERAL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(6312)
			p.Match(MySqlParserID)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(6313)
			p.Match(MySqlParserADMIN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(6314)
			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 (s *HostNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitHostName(s)

	default:
		return t.VisitChildren(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(6317)
		_la = p.GetTokenStream().LA(1)

		if !((int64((_la-1137)) & ^0x3f) == 0 && ((int64(1)<<(_la-1137))&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 (s *UserNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitUserName(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *MySqlParser) UserName() (localctx IUserNameContext) {
	localctx = NewUserNameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 564, MySqlParserRULE_userName)
	p.SetState(6324)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 928, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(6319)
			p.SimpleUserName()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(6320)
			p.SimpleUserName()
		}
		{
			p.SetState(6321)
			p.HostName()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(6323)
			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 (s *MysqlVariableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitMysqlVariable(s)

	default:
		return t.VisitChildren(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(6326)
		_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 (s *CharsetNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCharsetName(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *MySqlParser) CharsetName() (localctx ICharsetNameContext) {
	localctx = NewCharsetNameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 568, MySqlParserRULE_charsetName)
	p.SetState(6332)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 929, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(6328)
			p.Match(MySqlParserBINARY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(6329)
			p.CharsetNameBase()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(6330)
			p.Match(MySqlParserSTRING_LITERAL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(6331)
			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 (s *CollationNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCollationName(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *MySqlParser) CollationName() (localctx ICollationNameContext) {
	localctx = NewCollationNameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 570, MySqlParserRULE_collationName)
	p.SetState(6336)
	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(6334)
			p.Uid()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(6335)
			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 (s *EngineNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitEngineName(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *MySqlParser) EngineName() (localctx IEngineNameContext) {
	localctx = NewEngineNameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 572, MySqlParserRULE_engineName)
	p.SetState(6341)
	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(6338)
			p.EngineNameBase()
		}

	case MySqlParserID:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(6339)
			p.Match(MySqlParserID)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserSTRING_LITERAL:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(6340)
			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 (s *EngineNameBaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitEngineNameBase(s)

	default:
		return t.VisitChildren(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(6343)
		_la = p.GetTokenStream().LA(1)

		if !(_la == MySqlParserCONNECT || ((int64((_la-787)) & ^0x3f) == 0 && ((int64(1)<<(_la-787))&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 (s *UuidSetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitUuidSet(s)

	default:
		return t.VisitChildren(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(6345)
		p.DecimalLiteral()
	}
	{
		p.SetState(6346)
		p.Match(MySqlParserMINUS)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(6347)
		p.DecimalLiteral()
	}
	{
		p.SetState(6348)
		p.Match(MySqlParserMINUS)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(6349)
		p.DecimalLiteral()
	}
	{
		p.SetState(6350)
		p.Match(MySqlParserMINUS)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(6351)
		p.DecimalLiteral()
	}
	{
		p.SetState(6352)
		p.Match(MySqlParserMINUS)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(6353)
		p.DecimalLiteral()
	}
	p.SetState(6359)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = _la == MySqlParserCOLON_SYMB {
		{
			p.SetState(6354)
			p.Match(MySqlParserCOLON_SYMB)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6355)
			p.DecimalLiteral()
		}
		{
			p.SetState(6356)
			p.Match(MySqlParserMINUS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6357)
			p.DecimalLiteral()
		}

		p.SetState(6361)
		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 (s *XidContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitXid(s)

	default:
		return t.VisitChildren(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(6363)

		var _x = p.XuidStringId()

		localctx.(*XidContext).globalTableUid = _x
	}
	p.SetState(6370)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == MySqlParserCOMMA {
		{
			p.SetState(6364)
			p.Match(MySqlParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6365)

			var _x = p.XuidStringId()

			localctx.(*XidContext).qualifier = _x
		}
		p.SetState(6368)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserCOMMA {
			{
				p.SetState(6366)
				p.Match(MySqlParserCOMMA)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(6367)

				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 (s *XuidStringIdContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitXuidStringId(s)

	default:
		return t.VisitChildren(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(6379)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case MySqlParserSTRING_LITERAL:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(6372)
			p.Match(MySqlParserSTRING_LITERAL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserBIT_STRING:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(6373)
			p.Match(MySqlParserBIT_STRING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserHEXADECIMAL_LITERAL:
		p.EnterOuterAlt(localctx, 3)
		p.SetState(6375)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		for ok := true; ok; ok = _la == MySqlParserHEXADECIMAL_LITERAL {
			{
				p.SetState(6374)
				p.Match(MySqlParserHEXADECIMAL_LITERAL)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

			p.SetState(6377)
			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 (s *AuthPluginContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAuthPlugin(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *MySqlParser) AuthPlugin() (localctx IAuthPluginContext) {
	localctx = NewAuthPluginContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 582, MySqlParserRULE_authPlugin)
	p.SetState(6383)
	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(6381)
			p.Uid()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(6382)
			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 (s *UidContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitUid(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *MySqlParser) Uid() (localctx IUidContext) {
	localctx = NewUidContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 584, MySqlParserRULE_uid)
	p.SetState(6388)
	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, 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, 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, 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(6385)
			p.SimpleId()
		}

	case MySqlParserCHARSET_REVERSE_QOUTE_STRING:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(6386)
			p.Match(MySqlParserCHARSET_REVERSE_QOUTE_STRING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserSTRING_LITERAL:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(6387)
			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 (s *SimpleIdContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSimpleId(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *MySqlParser) SimpleId() (localctx ISimpleIdContext) {
	localctx = NewSimpleIdContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 586, MySqlParserRULE_simpleId)
	p.SetState(6399)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 939, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(6390)
			p.Match(MySqlParserID)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(6391)
			p.CharsetNameBase()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(6392)
			p.TransactionLevelBase()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(6393)
			p.EngineNameBase()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(6394)
			p.PrivilegesBase()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(6395)
			p.IntervalTypeBase()
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(6396)
			p.DataTypeBase()
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(6397)
			p.KeywordsCanBeId()
		}

	case 9:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(6398)
			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 (s *DottedIdContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitDottedId(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *MySqlParser) DottedId() (localctx IDottedIdContext) {
	localctx = NewDottedIdContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 588, MySqlParserRULE_dottedId)
	p.SetState(6404)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case MySqlParserDOT_ID:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(6401)
			p.Match(MySqlParserDOT_ID)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserDOT:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(6402)
			p.Match(MySqlParserDOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6403)
			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 (s *DecimalLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitDecimalLiteral(s)

	default:
		return t.VisitChildren(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(6406)
		_la = p.GetTokenStream().LA(1)

		if !((int64((_la-1138)) & ^0x3f) == 0 && ((int64(1)<<(_la-1138))&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 (s *FileSizeLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitFileSizeLiteral(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *MySqlParser) FileSizeLiteral() (localctx IFileSizeLiteralContext) {
	localctx = NewFileSizeLiteralContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 592, MySqlParserRULE_fileSizeLiteral)
	p.SetState(6410)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case MySqlParserFILESIZE_LITERAL:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(6408)
			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(6409)
			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 (s *StringLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitStringLiteral(s)

	default:
		return t.VisitChildren(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(6435)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 948, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		p.SetState(6417)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetTokenStream().LA(1) {
		case MySqlParserSTRING_LITERAL, MySqlParserSTRING_CHARSET_NAME:
			p.SetState(6413)
			p.GetErrorHandler().Sync(p)
			if p.HasError() {
				goto errorExit
			}
			_la = p.GetTokenStream().LA(1)

			if _la == MySqlParserSTRING_CHARSET_NAME {
				{
					p.SetState(6412)
					p.Match(MySqlParserSTRING_CHARSET_NAME)
					if p.HasError() {
						// Recognition error - abort rule
						goto errorExit
					}
				}

			}
			{
				p.SetState(6415)
				p.Match(MySqlParserSTRING_LITERAL)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		case MySqlParserSTART_NATIONAL_STRING_LITERAL:
			{
				p.SetState(6416)
				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(6420)
		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(6419)
					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(6422)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 944, p.GetParserRuleContext())
			if p.HasError() {
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		p.SetState(6429)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetTokenStream().LA(1) {
		case MySqlParserSTRING_LITERAL, MySqlParserSTRING_CHARSET_NAME:
			p.SetState(6425)
			p.GetErrorHandler().Sync(p)
			if p.HasError() {
				goto errorExit
			}
			_la = p.GetTokenStream().LA(1)

			if _la == MySqlParserSTRING_CHARSET_NAME {
				{
					p.SetState(6424)
					p.Match(MySqlParserSTRING_CHARSET_NAME)
					if p.HasError() {
						// Recognition error - abort rule
						goto errorExit
					}
				}

			}
			{
				p.SetState(6427)
				p.Match(MySqlParserSTRING_LITERAL)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		case MySqlParserSTART_NATIONAL_STRING_LITERAL:
			{
				p.SetState(6428)
				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(6433)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 947, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(6431)
				p.Match(MySqlParserCOLLATE)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(6432)
				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 (s *BooleanLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitBooleanLiteral(s)

	default:
		return t.VisitChildren(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(6437)
		_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 (s *HexadecimalLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitHexadecimalLiteral(s)

	default:
		return t.VisitChildren(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(6440)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == MySqlParserSTRING_CHARSET_NAME {
		{
			p.SetState(6439)
			p.Match(MySqlParserSTRING_CHARSET_NAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	}
	{
		p.SetState(6442)
		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 (s *NullNotnullContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitNullNotnull(s)

	default:
		return t.VisitChildren(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(6445)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == MySqlParserNOT {
		{
			p.SetState(6444)
			p.Match(MySqlParserNOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	}
	{
		p.SetState(6447)
		_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 (s *ConstantContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitConstant(s)

	default:
		return t.VisitChildren(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(6461)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 952, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(6449)
			p.StringLiteral()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(6450)
			p.DecimalLiteral()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(6451)
			p.Match(MySqlParserMINUS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6452)
			p.DecimalLiteral()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(6453)
			p.HexadecimalLiteral()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(6454)
			p.BooleanLiteral()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(6455)
			p.Match(MySqlParserREAL_LITERAL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(6456)
			p.Match(MySqlParserBIT_STRING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		p.SetState(6458)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserNOT {
			{
				p.SetState(6457)
				p.Match(MySqlParserNOT)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		}
		{
			p.SetState(6460)

			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)
	}
}

func (s *SpatialDataTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSpatialDataType(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *LongVarbinaryDataTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitLongVarbinaryDataType(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *CollectionDataTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCollectionDataType(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *NationalVaryingStringDataTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitNationalVaryingStringDataType(s)

	default:
		return t.VisitChildren(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) 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)
	}
}

func (s *DimensionDataTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitDimensionDataType(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *StringDataTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitStringDataType(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *LongVarcharDataTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitLongVarcharDataType(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *NationalStringDataTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitNationalStringDataType(s)

	default:
		return t.VisitChildren(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 (s *SimpleDataTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSimpleDataType(s)

	default:
		return t.VisitChildren(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(6589)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 981, p.GetParserRuleContext()) {
	case 1:
		localctx = NewStringDataTypeContext(p, localctx)
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(6463)

			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(6465)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserVARYING {
			{
				p.SetState(6464)
				p.Match(MySqlParserVARYING)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		}
		p.SetState(6468)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 954, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(6467)
				p.LengthOneDimension()
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}
		p.SetState(6471)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 955, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(6470)
				p.Match(MySqlParserBINARY)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}
		p.SetState(6476)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 956, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(6473)
				p.CharSet()
			}
			{
				p.SetState(6474)
				p.CharsetName()
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}
		p.SetState(6481)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 957, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(6478)
				p.Match(MySqlParserCOLLATE)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(6479)
				p.CollationName()
			}

		} else if p.HasError() { // JIM
			goto errorExit
		} else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 957, p.GetParserRuleContext()) == 2 {
			{
				p.SetState(6480)
				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(6483)
			p.Match(MySqlParserNATIONAL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6484)

			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(6485)
			p.Match(MySqlParserVARYING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(6487)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 958, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(6486)
				p.LengthOneDimension()
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}
		p.SetState(6490)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 959, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(6489)
				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(6492)
			p.Match(MySqlParserNATIONAL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6493)

			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(6495)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 960, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(6494)
				p.LengthOneDimension()
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}
		p.SetState(6498)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 961, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(6497)
				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(6500)
			p.Match(MySqlParserNCHAR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6501)

			var _m = p.Match(MySqlParserVARCHAR)

			localctx.(*NationalStringDataTypeContext).typeName = _m
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(6503)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 962, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(6502)
				p.LengthOneDimension()
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}
		p.SetState(6506)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 963, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(6505)
				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(6508)

			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(6510)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 964, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(6509)
				p.LengthOneDimension()
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}
		p.SetState(6515)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 965, p.GetParserRuleContext())
		if p.HasError() {
			goto errorExit
		}
		for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
			if _alt == 1 {
				{
					p.SetState(6512)
					_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(6517)
			p.GetErrorHandler().Sync(p)
			if p.HasError() {
				goto errorExit
			}
			_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 965, p.GetParserRuleContext())
			if p.HasError() {
				goto errorExit
			}
		}

	case 6:
		localctx = NewDimensionDataTypeContext(p, localctx)
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(6518)

			var _m = p.Match(MySqlParserREAL)

			localctx.(*DimensionDataTypeContext).typeName = _m
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(6520)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 966, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(6519)
				p.LengthTwoDimension()
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}
		p.SetState(6525)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 967, p.GetParserRuleContext())
		if p.HasError() {
			goto errorExit
		}
		for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
			if _alt == 1 {
				{
					p.SetState(6522)
					_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(6527)
			p.GetErrorHandler().Sync(p)
			if p.HasError() {
				goto errorExit
			}
			_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 967, p.GetParserRuleContext())
			if p.HasError() {
				goto errorExit
			}
		}

	case 7:
		localctx = NewDimensionDataTypeContext(p, localctx)
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(6528)

			var _m = p.Match(MySqlParserDOUBLE)

			localctx.(*DimensionDataTypeContext).typeName = _m
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(6530)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserPRECISION {
			{
				p.SetState(6529)
				p.Match(MySqlParserPRECISION)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		}
		p.SetState(6533)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 969, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(6532)
				p.LengthTwoDimension()
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}
		p.SetState(6538)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 970, p.GetParserRuleContext())
		if p.HasError() {
			goto errorExit
		}
		for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
			if _alt == 1 {
				{
					p.SetState(6535)
					_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(6540)
			p.GetErrorHandler().Sync(p)
			if p.HasError() {
				goto errorExit
			}
			_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 970, p.GetParserRuleContext())
			if p.HasError() {
				goto errorExit
			}
		}

	case 8:
		localctx = NewDimensionDataTypeContext(p, localctx)
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(6541)

			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(6543)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 971, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(6542)
				p.LengthTwoOptionalDimension()
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}
		p.SetState(6548)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 972, p.GetParserRuleContext())
		if p.HasError() {
			goto errorExit
		}
		for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
			if _alt == 1 {
				{
					p.SetState(6545)
					_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(6550)
			p.GetErrorHandler().Sync(p)
			if p.HasError() {
				goto errorExit
			}
			_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 972, p.GetParserRuleContext())
			if p.HasError() {
				goto errorExit
			}
		}

	case 9:
		localctx = NewSimpleDataTypeContext(p, localctx)
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(6551)

			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(6552)

			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))&2831) != 0) || _la == MySqlParserBIT) {
				var _ri = p.GetErrorHandler().RecoverInline(p)

				localctx.(*DimensionDataTypeContext).typeName = _ri
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		p.SetState(6554)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 973, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(6553)
				p.LengthOneDimension()
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}

	case 11:
		localctx = NewCollectionDataTypeContext(p, localctx)
		p.EnterOuterAlt(localctx, 11)
		{
			p.SetState(6556)

			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(6557)
			p.CollectionOptions()
		}
		p.SetState(6559)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 974, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(6558)
				p.Match(MySqlParserBINARY)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}
		p.SetState(6564)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 975, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(6561)
				p.CharSet()
			}
			{
				p.SetState(6562)
				p.CharsetName()
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}

	case 12:
		localctx = NewSpatialDataTypeContext(p, localctx)
		p.EnterOuterAlt(localctx, 12)
		{
			p.SetState(6566)

			var _lt = p.GetTokenStream().LT(1)

			localctx.(*SpatialDataTypeContext).typeName = _lt

			_la = p.GetTokenStream().LA(1)

			if !(_la == MySqlParserJSON || ((int64((_la-803)) & ^0x3f) == 0 && ((int64(1)<<(_la-803))&511) != 0)) {
				var _ri = p.GetErrorHandler().RecoverInline(p)

				localctx.(*SpatialDataTypeContext).typeName = _ri
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		p.SetState(6569)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 976, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(6567)
				p.Match(MySqlParserSRID)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(6568)
				p.DecimalLiteral()
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}

	case 13:
		localctx = NewLongVarcharDataTypeContext(p, localctx)
		p.EnterOuterAlt(localctx, 13)
		{
			p.SetState(6571)

			var _m = p.Match(MySqlParserLONG)

			localctx.(*LongVarcharDataTypeContext).typeName = _m
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(6573)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserVARCHAR {
			{
				p.SetState(6572)
				p.Match(MySqlParserVARCHAR)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		}
		p.SetState(6576)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 978, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(6575)
				p.Match(MySqlParserBINARY)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}
		p.SetState(6581)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 979, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(6578)
				p.CharSet()
			}
			{
				p.SetState(6579)
				p.CharsetName()
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}
		p.SetState(6585)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 980, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(6583)
				p.Match(MySqlParserCOLLATE)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(6584)
				p.CollationName()
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}

	case 14:
		localctx = NewLongVarbinaryDataTypeContext(p, localctx)
		p.EnterOuterAlt(localctx, 14)
		{
			p.SetState(6587)
			p.Match(MySqlParserLONG)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6588)
			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 (s *CollectionOptionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCollectionOptions(s)

	default:
		return t.VisitChildren(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(6591)
		p.Match(MySqlParserLR_BRACKET)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(6592)
		p.Match(MySqlParserSTRING_LITERAL)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(6597)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == MySqlParserCOMMA {
		{
			p.SetState(6593)
			p.Match(MySqlParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6594)
			p.Match(MySqlParserSTRING_LITERAL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

		p.SetState(6599)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(6600)
		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 (s *ConvertedDataTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitConvertedDataType(s)

	default:
		return t.VisitChildren(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(6624)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case MySqlParserFLOAT, MySqlParserBINARY, MySqlParserNCHAR:
		{
			p.SetState(6602)

			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(6604)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserLR_BRACKET {
			{
				p.SetState(6603)
				p.LengthOneDimension()
			}

		}

	case MySqlParserCHAR:
		{
			p.SetState(6606)

			var _m = p.Match(MySqlParserCHAR)

			localctx.(*ConvertedDataTypeContext).typeName = _m
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(6608)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserLR_BRACKET {
			{
				p.SetState(6607)
				p.LengthOneDimension()
			}

		}
		p.SetState(6613)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserCHARACTER || _la == MySqlParserCHAR || _la == MySqlParserCHARSET {
			{
				p.SetState(6610)
				p.CharSet()
			}
			{
				p.SetState(6611)
				p.CharsetName()
			}

		}

	case MySqlParserINT, MySqlParserINTEGER, MySqlParserDOUBLE, MySqlParserDATE, MySqlParserTIME, MySqlParserDATETIME, MySqlParserYEAR, MySqlParserJSON:
		{
			p.SetState(6615)

			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(6616)

			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(6618)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserLR_BRACKET {
			{
				p.SetState(6617)
				p.LengthTwoOptionalDimension()
			}

		}

	case MySqlParserUNSIGNED, MySqlParserSIGNED:
		{
			p.SetState(6620)
			_la = p.GetTokenStream().LA(1)

			if !(_la == MySqlParserUNSIGNED || _la == MySqlParserSIGNED) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		p.SetState(6622)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserINT || _la == MySqlParserINTEGER {
			{
				p.SetState(6621)
				_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(6627)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == MySqlParserARRAY {
		{
			p.SetState(6626)
			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 (s *LengthOneDimensionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitLengthOneDimension(s)

	default:
		return t.VisitChildren(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(6629)
		p.Match(MySqlParserLR_BRACKET)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(6630)
		p.DecimalLiteral()
	}
	{
		p.SetState(6631)
		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 (s *LengthTwoDimensionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitLengthTwoDimension(s)

	default:
		return t.VisitChildren(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(6633)
		p.Match(MySqlParserLR_BRACKET)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(6634)
		p.DecimalLiteral()
	}
	{
		p.SetState(6635)
		p.Match(MySqlParserCOMMA)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(6636)
		p.DecimalLiteral()
	}
	{
		p.SetState(6637)
		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 (s *LengthTwoOptionalDimensionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitLengthTwoOptionalDimension(s)

	default:
		return t.VisitChildren(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(6639)
		p.Match(MySqlParserLR_BRACKET)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(6640)
		p.DecimalLiteral()
	}
	p.SetState(6643)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == MySqlParserCOMMA {
		{
			p.SetState(6641)
			p.Match(MySqlParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6642)
			p.DecimalLiteral()
		}

	}
	{
		p.SetState(6645)
		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 (s *UidListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitUidList(s)

	default:
		return t.VisitChildren(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(6647)
		p.Uid()
	}
	p.SetState(6652)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 991, p.GetParserRuleContext())
	if p.HasError() {
		goto errorExit
	}
	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(6648)
				p.Match(MySqlParserCOMMA)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(6649)
				p.Uid()
			}

		}
		p.SetState(6654)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 991, 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 (s *FullColumnNameListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitFullColumnNameList(s)

	default:
		return t.VisitChildren(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(6655)
		p.FullColumnName()
	}
	p.SetState(6660)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == MySqlParserCOMMA {
		{
			p.SetState(6656)
			p.Match(MySqlParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6657)
			p.FullColumnName()
		}

		p.SetState(6662)
		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 (s *TablesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTables(s)

	default:
		return t.VisitChildren(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(6663)
		p.TableName()
	}
	p.SetState(6668)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 993, p.GetParserRuleContext())
	if p.HasError() {
		goto errorExit
	}
	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(6664)
				p.Match(MySqlParserCOMMA)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(6665)
				p.TableName()
			}

		}
		p.SetState(6670)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 993, 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 (s *IndexColumnNamesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitIndexColumnNames(s)

	default:
		return t.VisitChildren(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(6671)
		p.Match(MySqlParserLR_BRACKET)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(6672)
		p.IndexColumnName()
	}
	p.SetState(6677)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == MySqlParserCOMMA {
		{
			p.SetState(6673)
			p.Match(MySqlParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6674)
			p.IndexColumnName()
		}

		p.SetState(6679)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(6680)
		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 (s *ExpressionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitExpressions(s)

	default:
		return t.VisitChildren(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(6682)
		p.expression(0)
	}
	p.SetState(6687)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == MySqlParserCOMMA {
		{
			p.SetState(6683)
			p.Match(MySqlParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6684)
			p.expression(0)
		}

		p.SetState(6689)
		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 (s *ExpressionsWithDefaultsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitExpressionsWithDefaults(s)

	default:
		return t.VisitChildren(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(6690)
		p.ExpressionOrDefault()
	}
	p.SetState(6695)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == MySqlParserCOMMA {
		{
			p.SetState(6691)
			p.Match(MySqlParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6692)
			p.ExpressionOrDefault()
		}

		p.SetState(6697)
		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 (s *ConstantsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitConstants(s)

	default:
		return t.VisitChildren(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(6698)
		p.Constant()
	}
	p.SetState(6703)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == MySqlParserCOMMA {
		{
			p.SetState(6699)
			p.Match(MySqlParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6700)
			p.Constant()
		}

		p.SetState(6705)
		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 (s *SimpleStringsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSimpleStrings(s)

	default:
		return t.VisitChildren(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(6706)
		p.Match(MySqlParserSTRING_LITERAL)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(6711)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == MySqlParserCOMMA {
		{
			p.SetState(6707)
			p.Match(MySqlParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6708)
			p.Match(MySqlParserSTRING_LITERAL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

		p.SetState(6713)
		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 (s *UserVariablesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitUserVariables(s)

	default:
		return t.VisitChildren(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(6714)
		p.Match(MySqlParserLOCAL_ID)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(6719)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == MySqlParserCOMMA {
		{
			p.SetState(6715)
			p.Match(MySqlParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6716)
			p.Match(MySqlParserLOCAL_ID)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

		p.SetState(6721)
		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 (s *DefaultValueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitDefaultValue(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *MySqlParser) DefaultValue() (localctx IDefaultValueContext) {
	localctx = NewDefaultValueContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 634, MySqlParserRULE_defaultValue)
	p.SetState(6748)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1002, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(6722)
			p.Match(MySqlParserNULL_LITERAL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(6723)
			p.Match(MySqlParserCAST)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6724)
			p.Match(MySqlParserLR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6725)
			p.expression(0)
		}
		{
			p.SetState(6726)
			p.Match(MySqlParserAS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6727)
			p.ConvertedDataType()
		}
		{
			p.SetState(6728)
			p.Match(MySqlParserRR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		p.SetState(6731)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1000, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(6730)
				p.UnaryOperator()
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}
		{
			p.SetState(6733)
			p.Constant()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(6734)
			p.CurrentTimestamp()
		}
		p.SetState(6738)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1001, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(6735)
				p.Match(MySqlParserON)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(6736)
				p.Match(MySqlParserUPDATE)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(6737)
				p.CurrentTimestamp()
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(6740)
			p.Match(MySqlParserLR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6741)
			p.expression(0)
		}
		{
			p.SetState(6742)
			p.Match(MySqlParserRR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(6744)
			p.Match(MySqlParserLR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6745)
			p.FullId()
		}
		{
			p.SetState(6746)
			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 (s *CurrentTimestampContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCurrentTimestamp(s)

	default:
		return t.VisitChildren(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(6764)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case MySqlParserCURRENT_TIMESTAMP, MySqlParserLOCALTIME, MySqlParserLOCALTIMESTAMP:
		{
			p.SetState(6750)
			_la = p.GetTokenStream().LA(1)

			if !((int64((_la-315)) & ^0x3f) == 0 && ((int64(1)<<(_la-315))&131) != 0) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		p.SetState(6756)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1004, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(6751)
				p.Match(MySqlParserLR_BRACKET)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			p.SetState(6753)
			p.GetErrorHandler().Sync(p)
			if p.HasError() {
				goto errorExit
			}
			_la = p.GetTokenStream().LA(1)

			if (int64((_la-1138)) & ^0x3f) == 0 && ((int64(1)<<(_la-1138))&10247) != 0 {
				{
					p.SetState(6752)
					p.DecimalLiteral()
				}

			}
			{
				p.SetState(6755)
				p.Match(MySqlParserRR_BRACKET)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}

	case MySqlParserNOW:
		{
			p.SetState(6758)
			p.Match(MySqlParserNOW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6759)
			p.Match(MySqlParserLR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(6761)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if (int64((_la-1138)) & ^0x3f) == 0 && ((int64(1)<<(_la-1138))&10247) != 0 {
			{
				p.SetState(6760)
				p.DecimalLiteral()
			}

		}
		{
			p.SetState(6763)
			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 (s *ExpressionOrDefaultContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitExpressionOrDefault(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *MySqlParser) ExpressionOrDefault() (localctx IExpressionOrDefaultContext) {
	localctx = NewExpressionOrDefaultContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 638, MySqlParserRULE_expressionOrDefault)
	p.SetState(6768)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1007, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(6766)
			p.expression(0)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(6767)
			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 (s *IfExistsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitIfExists(s)

	default:
		return t.VisitChildren(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(6770)
		p.Match(MySqlParserIF)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(6771)
		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 (s *IfNotExistsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitIfNotExists(s)

	default:
		return t.VisitChildren(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(6773)
		p.Match(MySqlParserIF)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(6774)
		p.Match(MySqlParserNOT)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(6775)
		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 (s *OrReplaceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitOrReplace(s)

	default:
		return t.VisitChildren(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(6777)
		p.Match(MySqlParserOR)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(6778)
		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 (s *WaitNowaitClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitWaitNowaitClause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *MySqlParser) WaitNowaitClause() (localctx IWaitNowaitClauseContext) {
	localctx = NewWaitNowaitClauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 646, MySqlParserRULE_waitNowaitClause)
	p.SetState(6783)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case MySqlParserWAIT:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(6780)
			p.Match(MySqlParserWAIT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6781)
			p.DecimalLiteral()
		}

	case MySqlParserNOWAIT:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(6782)
			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)
	}
}

func (s *SpecificFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSpecificFunctionCall(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *PasswordFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitPasswordFunctionCall(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *UdfFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitUdfFunctionCall(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *NonAggregateFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitNonAggregateFunctionCall(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *AggregateFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAggregateFunctionCall(s)

	default:
		return t.VisitChildren(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 (s *ScalarFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitScalarFunctionCall(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *MySqlParser) FunctionCall() (localctx IFunctionCallContext) {
	localctx = NewFunctionCallContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 648, MySqlParserRULE_functionCall)
	p.SetState(6803)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1011, p.GetParserRuleContext()) {
	case 1:
		localctx = NewSpecificFunctionCallContext(p, localctx)
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(6785)
			p.SpecificFunction()
		}

	case 2:
		localctx = NewAggregateFunctionCallContext(p, localctx)
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(6786)
			p.AggregateWindowedFunction()
		}

	case 3:
		localctx = NewNonAggregateFunctionCallContext(p, localctx)
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(6787)
			p.NonAggregateWindowedFunction()
		}

	case 4:
		localctx = NewScalarFunctionCallContext(p, localctx)
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(6788)
			p.ScalarFunctionName()
		}
		{
			p.SetState(6789)
			p.Match(MySqlParserLR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(6791)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1009, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(6790)
				p.FunctionArgs()
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}
		{
			p.SetState(6793)
			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(6795)
			p.FullId()
		}
		{
			p.SetState(6796)
			p.Match(MySqlParserLR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(6798)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1010, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(6797)
				p.FunctionArgs()
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}
		{
			p.SetState(6800)
			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(6802)
			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)
	}
}

func (s *PositionFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitPositionFunctionCall(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *TrimFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTrimFunctionCall(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *JsonValueFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitJsonValueFunctionCall(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *CaseFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCaseFunctionCall(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *ExtractFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitExtractFunctionCall(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *DataTypeFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitDataTypeFunctionCall(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *ValuesFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitValuesFunctionCall(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *CaseExpressionFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCaseExpressionFunctionCall(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *CurrentUserContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCurrentUser(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *SimpleFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSimpleFunctionCall(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *CharFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCharFunctionCall(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *WeightFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitWeightFunctionCall(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *GetFormatFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitGetFormatFunctionCall(s)

	default:
		return t.VisitChildren(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 (s *SubstrFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSubstrFunctionCall(s)

	default:
		return t.VisitChildren(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(6984)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1035, p.GetParserRuleContext()) {
	case 1:
		localctx = NewSimpleFunctionCallContext(p, localctx)
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(6805)
			_la = p.GetTokenStream().LA(1)

			if !(_la == MySqlParserSCHEMA || ((int64((_la-313)) & ^0x3f) == 0 && ((int64(1)<<(_la-313))&262159) != 0)) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		p.SetState(6808)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1012, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(6806)
				p.Match(MySqlParserLR_BRACKET)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(6807)
				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(6810)
			p.CurrentUserExpression()
		}

	case 3:
		localctx = NewDataTypeFunctionCallContext(p, localctx)
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(6811)
			p.Match(MySqlParserCONVERT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6812)
			p.Match(MySqlParserLR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6813)
			p.expression(0)
		}
		{
			p.SetState(6814)

			var _m = p.Match(MySqlParserCOMMA)

			localctx.(*DataTypeFunctionCallContext).separator = _m
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6815)
			p.ConvertedDataType()
		}
		{
			p.SetState(6816)
			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(6818)
			p.Match(MySqlParserCONVERT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6819)
			p.Match(MySqlParserLR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6820)
			p.expression(0)
		}
		{
			p.SetState(6821)
			p.Match(MySqlParserUSING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6822)
			p.CharsetName()
		}
		{
			p.SetState(6823)
			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(6825)
			p.Match(MySqlParserCAST)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6826)
			p.Match(MySqlParserLR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6827)
			p.expression(0)
		}
		{
			p.SetState(6828)
			p.Match(MySqlParserAS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6829)
			p.ConvertedDataType()
		}
		{
			p.SetState(6830)
			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(6832)
			p.Match(MySqlParserVALUES)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6833)
			p.Match(MySqlParserLR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6834)
			p.FullColumnName()
		}
		{
			p.SetState(6835)
			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(6837)
			p.Match(MySqlParserCASE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6838)
			p.expression(0)
		}
		p.SetState(6840)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		for ok := true; ok; ok = _la == MySqlParserWHEN {
			{
				p.SetState(6839)
				p.CaseFuncAlternative()
			}

			p.SetState(6842)
			p.GetErrorHandler().Sync(p)
			if p.HasError() {
				goto errorExit
			}
			_la = p.GetTokenStream().LA(1)
		}
		p.SetState(6846)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserELSE {
			{
				p.SetState(6844)
				p.Match(MySqlParserELSE)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(6845)

				var _x = p.FunctionArg()

				localctx.(*CaseExpressionFunctionCallContext).elseArg = _x
			}

		}
		{
			p.SetState(6848)
			p.Match(MySqlParserEND)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 8:
		localctx = NewCaseFunctionCallContext(p, localctx)
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(6850)
			p.Match(MySqlParserCASE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(6852)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		for ok := true; ok; ok = _la == MySqlParserWHEN {
			{
				p.SetState(6851)
				p.CaseFuncAlternative()
			}

			p.SetState(6854)
			p.GetErrorHandler().Sync(p)
			if p.HasError() {
				goto errorExit
			}
			_la = p.GetTokenStream().LA(1)
		}
		p.SetState(6858)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserELSE {
			{
				p.SetState(6856)
				p.Match(MySqlParserELSE)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(6857)

				var _x = p.FunctionArg()

				localctx.(*CaseFunctionCallContext).elseArg = _x
			}

		}
		{
			p.SetState(6860)
			p.Match(MySqlParserEND)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 9:
		localctx = NewCharFunctionCallContext(p, localctx)
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(6862)
			p.Match(MySqlParserCHAR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6863)
			p.Match(MySqlParserLR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6864)
			p.FunctionArgs()
		}
		p.SetState(6867)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserUSING {
			{
				p.SetState(6865)
				p.Match(MySqlParserUSING)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(6866)
				p.CharsetName()
			}

		}
		{
			p.SetState(6869)
			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(6871)
			p.Match(MySqlParserPOSITION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6872)
			p.Match(MySqlParserLR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(6875)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1018, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(6873)

				var _x = p.StringLiteral()

				localctx.(*PositionFunctionCallContext).positionString = _x
			}

		case 2:
			{
				p.SetState(6874)

				var _x = p.expression(0)

				localctx.(*PositionFunctionCallContext).positionExpression = _x
			}

		case antlr.ATNInvalidAltNumber:
			goto errorExit
		}
		{
			p.SetState(6877)
			p.Match(MySqlParserIN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(6880)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1019, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(6878)

				var _x = p.StringLiteral()

				localctx.(*PositionFunctionCallContext).inString = _x
			}

		case 2:
			{
				p.SetState(6879)

				var _x = p.expression(0)

				localctx.(*PositionFunctionCallContext).inExpression = _x
			}

		case antlr.ATNInvalidAltNumber:
			goto errorExit
		}
		{
			p.SetState(6882)
			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(6884)
			_la = p.GetTokenStream().LA(1)

			if !(_la == MySqlParserSUBSTR || _la == MySqlParserSUBSTRING) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(6885)
			p.Match(MySqlParserLR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(6888)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1020, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(6886)

				var _x = p.StringLiteral()

				localctx.(*SubstrFunctionCallContext).sourceString = _x
			}

		case 2:
			{
				p.SetState(6887)

				var _x = p.expression(0)

				localctx.(*SubstrFunctionCallContext).sourceExpression = _x
			}

		case antlr.ATNInvalidAltNumber:
			goto errorExit
		}
		{
			p.SetState(6890)
			p.Match(MySqlParserFROM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(6893)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1021, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(6891)

				var _x = p.DecimalLiteral()

				localctx.(*SubstrFunctionCallContext).fromDecimal = _x
			}

		case 2:
			{
				p.SetState(6892)

				var _x = p.expression(0)

				localctx.(*SubstrFunctionCallContext).fromExpression = _x
			}

		case antlr.ATNInvalidAltNumber:
			goto errorExit
		}
		p.SetState(6900)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserFOR {
			{
				p.SetState(6895)
				p.Match(MySqlParserFOR)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			p.SetState(6898)
			p.GetErrorHandler().Sync(p)
			if p.HasError() {
				goto errorExit
			}

			switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1022, p.GetParserRuleContext()) {
			case 1:
				{
					p.SetState(6896)

					var _x = p.DecimalLiteral()

					localctx.(*SubstrFunctionCallContext).forDecimal = _x
				}

			case 2:
				{
					p.SetState(6897)

					var _x = p.expression(0)

					localctx.(*SubstrFunctionCallContext).forExpression = _x
				}

			case antlr.ATNInvalidAltNumber:
				goto errorExit
			}

		}
		{
			p.SetState(6902)
			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(6904)
			p.Match(MySqlParserTRIM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6905)
			p.Match(MySqlParserLR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6906)

			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(6909)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1024, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(6907)

				var _x = p.StringLiteral()

				localctx.(*TrimFunctionCallContext).sourceString = _x
			}

		} else if p.HasError() { // JIM
			goto errorExit
		} else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1024, p.GetParserRuleContext()) == 2 {
			{
				p.SetState(6908)

				var _x = p.expression(0)

				localctx.(*TrimFunctionCallContext).sourceExpression = _x
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}
		{
			p.SetState(6911)
			p.Match(MySqlParserFROM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(6914)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1025, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(6912)

				var _x = p.StringLiteral()

				localctx.(*TrimFunctionCallContext).fromString = _x
			}

		case 2:
			{
				p.SetState(6913)

				var _x = p.expression(0)

				localctx.(*TrimFunctionCallContext).fromExpression = _x
			}

		case antlr.ATNInvalidAltNumber:
			goto errorExit
		}
		{
			p.SetState(6916)
			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(6918)
			p.Match(MySqlParserTRIM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6919)
			p.Match(MySqlParserLR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(6922)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1026, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(6920)

				var _x = p.StringLiteral()

				localctx.(*TrimFunctionCallContext).sourceString = _x
			}

		case 2:
			{
				p.SetState(6921)

				var _x = p.expression(0)

				localctx.(*TrimFunctionCallContext).sourceExpression = _x
			}

		case antlr.ATNInvalidAltNumber:
			goto errorExit
		}
		{
			p.SetState(6924)
			p.Match(MySqlParserFROM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(6927)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1027, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(6925)

				var _x = p.StringLiteral()

				localctx.(*TrimFunctionCallContext).fromString = _x
			}

		case 2:
			{
				p.SetState(6926)

				var _x = p.expression(0)

				localctx.(*TrimFunctionCallContext).fromExpression = _x
			}

		case antlr.ATNInvalidAltNumber:
			goto errorExit
		}
		{
			p.SetState(6929)
			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(6931)
			p.Match(MySqlParserWEIGHT_STRING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6932)
			p.Match(MySqlParserLR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(6935)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1028, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(6933)
				p.StringLiteral()
			}

		case 2:
			{
				p.SetState(6934)
				p.expression(0)
			}

		case antlr.ATNInvalidAltNumber:
			goto errorExit
		}
		p.SetState(6943)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserAS {
			{
				p.SetState(6937)
				p.Match(MySqlParserAS)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(6938)

				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(6939)
				p.Match(MySqlParserLR_BRACKET)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(6940)
				p.DecimalLiteral()
			}
			{
				p.SetState(6941)
				p.Match(MySqlParserRR_BRACKET)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		}
		p.SetState(6946)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserLEVEL {
			{
				p.SetState(6945)
				p.LevelsInWeightString()
			}

		}
		{
			p.SetState(6948)
			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(6950)
			p.Match(MySqlParserEXTRACT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6951)
			p.Match(MySqlParserLR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6952)
			p.IntervalType()
		}
		{
			p.SetState(6953)
			p.Match(MySqlParserFROM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(6956)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1031, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(6954)

				var _x = p.StringLiteral()

				localctx.(*ExtractFunctionCallContext).sourceString = _x
			}

		case 2:
			{
				p.SetState(6955)

				var _x = p.expression(0)

				localctx.(*ExtractFunctionCallContext).sourceExpression = _x
			}

		case antlr.ATNInvalidAltNumber:
			goto errorExit
		}
		{
			p.SetState(6958)
			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(6960)
			p.Match(MySqlParserGET_FORMAT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6961)
			p.Match(MySqlParserLR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6962)

			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(6963)
			p.Match(MySqlParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6964)
			p.StringLiteral()
		}
		{
			p.SetState(6965)
			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(6967)
			p.Match(MySqlParserJSON_VALUE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6968)
			p.Match(MySqlParserLR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6969)
			p.expression(0)
		}
		{
			p.SetState(6970)
			p.Match(MySqlParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6971)
			p.expression(0)
		}
		p.SetState(6974)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserRETURNING {
			{
				p.SetState(6972)
				p.Match(MySqlParserRETURNING)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(6973)
				p.ConvertedDataType()
			}

		}
		p.SetState(6977)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1033, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(6976)
				p.JsonOnEmpty()
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}
		p.SetState(6980)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserDEFAULT || _la == MySqlParserNULL_LITERAL || _la == MySqlParserERROR {
			{
				p.SetState(6979)
				p.JsonOnError()
			}

		}
		{
			p.SetState(6982)
			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 (s *CaseFuncAlternativeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCaseFuncAlternative(s)

	default:
		return t.VisitChildren(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(6986)
		p.Match(MySqlParserWHEN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(6987)

		var _x = p.FunctionArg()

		localctx.(*CaseFuncAlternativeContext).condition = _x
	}
	{
		p.SetState(6988)
		p.Match(MySqlParserTHEN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(6989)

		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)
	}
}

func (s *LevelWeightRangeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitLevelWeightRange(s)

	default:
		return t.VisitChildren(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 (s *LevelWeightListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitLevelWeightList(s)

	default:
		return t.VisitChildren(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(7005)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1037, p.GetParserRuleContext()) {
	case 1:
		localctx = NewLevelWeightListContext(p, localctx)
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(6991)
			p.Match(MySqlParserLEVEL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6992)
			p.LevelInWeightListElement()
		}
		p.SetState(6997)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		for _la == MySqlParserCOMMA {
			{
				p.SetState(6993)
				p.Match(MySqlParserCOMMA)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(6994)
				p.LevelInWeightListElement()
			}

			p.SetState(6999)
			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(7000)
			p.Match(MySqlParserLEVEL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7001)

			var _x = p.DecimalLiteral()

			localctx.(*LevelWeightRangeContext).firstLevel = _x
		}
		{
			p.SetState(7002)
			p.Match(MySqlParserMINUS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7003)

			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 (s *LevelInWeightListElementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitLevelInWeightListElement(s)

	default:
		return t.VisitChildren(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(7007)
		p.DecimalLiteral()
	}
	p.SetState(7009)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == MySqlParserASC || _la == MySqlParserDESC || _la == MySqlParserREVERSE {
		{
			p.SetState(7008)

			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 (s *AggregateWindowedFunctionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAggregateWindowedFunction(s)

	default:
		return t.VisitChildren(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(7070)
	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(7011)
			_la = p.GetTokenStream().LA(1)

			if !((int64((_la-286)) & ^0x3f) == 0 && ((int64(1)<<(_la-286))&8400897) != 0) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(7012)
			p.Match(MySqlParserLR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(7014)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1039, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(7013)

				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(7016)
			p.FunctionArg()
		}
		{
			p.SetState(7017)
			p.Match(MySqlParserRR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(7019)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1040, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(7018)
				p.OverClause()
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}

	case MySqlParserCOUNT:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(7021)
			p.Match(MySqlParserCOUNT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7022)
			p.Match(MySqlParserLR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(7030)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1042, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(7023)

				var _m = p.Match(MySqlParserSTAR)

				localctx.(*AggregateWindowedFunctionContext).starArg = _m
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		case 2:
			p.SetState(7025)
			p.GetErrorHandler().Sync(p)

			if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1041, p.GetParserRuleContext()) == 1 {
				{
					p.SetState(7024)

					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(7027)
				p.FunctionArg()
			}

		case 3:
			{
				p.SetState(7028)

				var _m = p.Match(MySqlParserDISTINCT)

				localctx.(*AggregateWindowedFunctionContext).aggregator = _m
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(7029)
				p.FunctionArgs()
			}

		case antlr.ATNInvalidAltNumber:
			goto errorExit
		}
		{
			p.SetState(7032)
			p.Match(MySqlParserRR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(7034)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1043, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(7033)
				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(7036)
			_la = p.GetTokenStream().LA(1)

			if !((int64((_la-287)) & ^0x3f) == 0 && ((int64(1)<<(_la-287))&62652423) != 0) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(7037)
			p.Match(MySqlParserLR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(7039)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1044, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(7038)

				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(7041)
			p.FunctionArg()
		}
		{
			p.SetState(7042)
			p.Match(MySqlParserRR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(7044)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1045, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(7043)
				p.OverClause()
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}

	case MySqlParserGROUP_CONCAT:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(7046)
			p.Match(MySqlParserGROUP_CONCAT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7047)
			p.Match(MySqlParserLR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(7049)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1046, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(7048)

				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(7051)
			p.FunctionArgs()
		}
		p.SetState(7062)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserORDER {
			{
				p.SetState(7052)
				p.Match(MySqlParserORDER)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(7053)
				p.Match(MySqlParserBY)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(7054)
				p.OrderByExpression()
			}
			p.SetState(7059)
			p.GetErrorHandler().Sync(p)
			if p.HasError() {
				goto errorExit
			}
			_la = p.GetTokenStream().LA(1)

			for _la == MySqlParserCOMMA {
				{
					p.SetState(7055)
					p.Match(MySqlParserCOMMA)
					if p.HasError() {
						// Recognition error - abort rule
						goto errorExit
					}
				}
				{
					p.SetState(7056)
					p.OrderByExpression()
				}

				p.SetState(7061)
				p.GetErrorHandler().Sync(p)
				if p.HasError() {
					goto errorExit
				}
				_la = p.GetTokenStream().LA(1)
			}

		}
		p.SetState(7066)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserSEPARATOR {
			{
				p.SetState(7064)
				p.Match(MySqlParserSEPARATOR)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(7065)

				var _m = p.Match(MySqlParserSTRING_LITERAL)

				localctx.(*AggregateWindowedFunctionContext).separator = _m
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		}
		{
			p.SetState(7068)
			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 (s *NonAggregateWindowedFunctionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitNonAggregateWindowedFunction(s)

	default:
		return t.VisitChildren(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(7110)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case MySqlParserLAG, MySqlParserLEAD:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7072)
			_la = p.GetTokenStream().LA(1)

			if !(_la == MySqlParserLAG || _la == MySqlParserLEAD) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(7073)
			p.Match(MySqlParserLR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7074)
			p.expression(0)
		}
		p.SetState(7077)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1051, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(7075)
				p.Match(MySqlParserCOMMA)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(7076)
				p.DecimalLiteral()
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}
		p.SetState(7081)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserCOMMA {
			{
				p.SetState(7079)
				p.Match(MySqlParserCOMMA)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(7080)
				p.DecimalLiteral()
			}

		}
		{
			p.SetState(7083)
			p.Match(MySqlParserRR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7084)
			p.OverClause()
		}

	case MySqlParserFIRST_VALUE, MySqlParserLAST_VALUE:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(7086)
			_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(7087)
			p.Match(MySqlParserLR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7088)
			p.expression(0)
		}
		{
			p.SetState(7089)
			p.Match(MySqlParserRR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7090)
			p.OverClause()
		}

	case MySqlParserCUME_DIST, MySqlParserDENSE_RANK, MySqlParserPERCENT_RANK, MySqlParserRANK, MySqlParserROW_NUMBER:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(7092)
			_la = p.GetTokenStream().LA(1)

			if !((int64((_la-291)) & ^0x3f) == 0 && ((int64(1)<<(_la-291))&14339) != 0) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(7093)
			p.Match(MySqlParserLR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7094)
			p.Match(MySqlParserRR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7095)
			p.OverClause()
		}

	case MySqlParserNTH_VALUE:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(7096)
			p.Match(MySqlParserNTH_VALUE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7097)
			p.Match(MySqlParserLR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7098)
			p.expression(0)
		}
		{
			p.SetState(7099)
			p.Match(MySqlParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7100)
			p.DecimalLiteral()
		}
		{
			p.SetState(7101)
			p.Match(MySqlParserRR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7102)
			p.OverClause()
		}

	case MySqlParserNTILE:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(7104)
			p.Match(MySqlParserNTILE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7105)
			p.Match(MySqlParserLR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7106)
			p.DecimalLiteral()
		}
		{
			p.SetState(7107)
			p.Match(MySqlParserRR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7108)
			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 (s *OverClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitOverClause(s)

	default:
		return t.VisitChildren(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(7112)
		p.Match(MySqlParserOVER)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(7118)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case MySqlParserLR_BRACKET:
		{
			p.SetState(7113)
			p.Match(MySqlParserLR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7114)
			p.WindowSpec()
		}
		{
			p.SetState(7115)
			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, 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, 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, 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(7117)
			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 (s *WindowSpecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitWindowSpec(s)

	default:
		return t.VisitChildren(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(7121)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1055, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(7120)
			p.WindowName()
		}

	} else if p.HasError() { // JIM
		goto errorExit
	}
	p.SetState(7124)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == MySqlParserPARTITION {
		{
			p.SetState(7123)
			p.PartitionClause()
		}

	}
	p.SetState(7127)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == MySqlParserORDER {
		{
			p.SetState(7126)
			p.OrderByClause()
		}

	}
	p.SetState(7130)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == MySqlParserRANGE || _la == MySqlParserROWS {
		{
			p.SetState(7129)
			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 (s *WindowNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitWindowName(s)

	default:
		return t.VisitChildren(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(7132)
		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 (s *FrameClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitFrameClause(s)

	default:
		return t.VisitChildren(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(7134)
		p.FrameUnits()
	}
	{
		p.SetState(7135)
		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 (s *FrameUnitsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitFrameUnits(s)

	default:
		return t.VisitChildren(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(7137)
		_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 (s *FrameExtentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitFrameExtent(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *MySqlParser) FrameExtent() (localctx IFrameExtentContext) {
	localctx = NewFrameExtentContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 672, MySqlParserRULE_frameExtent)
	p.SetState(7141)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1059, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7139)
			p.FrameRange()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(7140)
			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 (s *FrameBetweenContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitFrameBetween(s)

	default:
		return t.VisitChildren(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(7143)
		p.Match(MySqlParserBETWEEN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7144)
		p.FrameRange()
	}
	{
		p.SetState(7145)
		p.Match(MySqlParserAND)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7146)
		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 (s *FrameRangeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitFrameRange(s)

	default:
		return t.VisitChildren(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(7155)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1060, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7148)
			p.Match(MySqlParserCURRENT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7149)
			p.Match(MySqlParserROW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(7150)
			p.Match(MySqlParserUNBOUNDED)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7151)
			_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(7152)
			p.expression(0)
		}
		{
			p.SetState(7153)
			_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 (s *PartitionClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitPartitionClause(s)

	default:
		return t.VisitChildren(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(7157)
		p.Match(MySqlParserPARTITION)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7158)
		p.Match(MySqlParserBY)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7159)
		p.expression(0)
	}
	p.SetState(7164)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == MySqlParserCOMMA {
		{
			p.SetState(7160)
			p.Match(MySqlParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7161)
			p.expression(0)
		}

		p.SetState(7166)
		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 (s *ScalarFunctionNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitScalarFunctionName(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *MySqlParser) ScalarFunctionName() (localctx IScalarFunctionNameContext) {
	localctx = NewScalarFunctionNameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 680, MySqlParserRULE_scalarFunctionName)
	p.SetState(7191)
	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, 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, 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, MySqlParserVERSION, MySqlParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS, MySqlParserWEEKDAY, MySqlParserWEEKOFYEAR, MySqlParserWEIGHT_STRING, MySqlParserWITHIN, MySqlParserYEARWEEK, MySqlParserY_FUNCTION, MySqlParserX_FUNCTION, MySqlParserMOD:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7167)
			p.FunctionNameBase()
		}

	case MySqlParserASCII:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(7168)
			p.Match(MySqlParserASCII)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserCURDATE:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(7169)
			p.Match(MySqlParserCURDATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserCURRENT_DATE:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(7170)
			p.Match(MySqlParserCURRENT_DATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserCURRENT_TIME:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(7171)
			p.Match(MySqlParserCURRENT_TIME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserCURRENT_TIMESTAMP:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(7172)
			p.Match(MySqlParserCURRENT_TIMESTAMP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserCURTIME:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(7173)
			p.Match(MySqlParserCURTIME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserDATE_ADD:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(7174)
			p.Match(MySqlParserDATE_ADD)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserDATE_SUB:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(7175)
			p.Match(MySqlParserDATE_SUB)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserIF:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(7176)
			p.Match(MySqlParserIF)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserINSERT:
		p.EnterOuterAlt(localctx, 11)
		{
			p.SetState(7177)
			p.Match(MySqlParserINSERT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserLOCALTIME:
		p.EnterOuterAlt(localctx, 12)
		{
			p.SetState(7178)
			p.Match(MySqlParserLOCALTIME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserLOCALTIMESTAMP:
		p.EnterOuterAlt(localctx, 13)
		{
			p.SetState(7179)
			p.Match(MySqlParserLOCALTIMESTAMP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserMID:
		p.EnterOuterAlt(localctx, 14)
		{
			p.SetState(7180)
			p.Match(MySqlParserMID)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserNOW:
		p.EnterOuterAlt(localctx, 15)
		{
			p.SetState(7181)
			p.Match(MySqlParserNOW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserREPEAT:
		p.EnterOuterAlt(localctx, 16)
		{
			p.SetState(7182)
			p.Match(MySqlParserREPEAT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserREPLACE:
		p.EnterOuterAlt(localctx, 17)
		{
			p.SetState(7183)
			p.Match(MySqlParserREPLACE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserSUBSTR:
		p.EnterOuterAlt(localctx, 18)
		{
			p.SetState(7184)
			p.Match(MySqlParserSUBSTR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserSUBSTRING:
		p.EnterOuterAlt(localctx, 19)
		{
			p.SetState(7185)
			p.Match(MySqlParserSUBSTRING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserSYSDATE:
		p.EnterOuterAlt(localctx, 20)
		{
			p.SetState(7186)
			p.Match(MySqlParserSYSDATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserTRIM:
		p.EnterOuterAlt(localctx, 21)
		{
			p.SetState(7187)
			p.Match(MySqlParserTRIM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserUTC_DATE:
		p.EnterOuterAlt(localctx, 22)
		{
			p.SetState(7188)
			p.Match(MySqlParserUTC_DATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserUTC_TIME:
		p.EnterOuterAlt(localctx, 23)
		{
			p.SetState(7189)
			p.Match(MySqlParserUTC_TIME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserUTC_TIMESTAMP:
		p.EnterOuterAlt(localctx, 24)
		{
			p.SetState(7190)
			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 (s *PasswordFunctionClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitPasswordFunctionClause(s)

	default:
		return t.VisitChildren(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(7193)

		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(7194)
		p.Match(MySqlParserLR_BRACKET)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7195)
		p.FunctionArg()
	}
	{
		p.SetState(7196)
		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 (s *FunctionArgsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitFunctionArgs(s)

	default:
		return t.VisitChildren(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(7202)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1063, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(7198)
			p.Constant()
		}

	case 2:
		{
			p.SetState(7199)
			p.FullColumnName()
		}

	case 3:
		{
			p.SetState(7200)
			p.FunctionCall()
		}

	case 4:
		{
			p.SetState(7201)
			p.expression(0)
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}
	p.SetState(7213)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == MySqlParserCOMMA {
		{
			p.SetState(7204)
			p.Match(MySqlParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(7209)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1064, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(7205)
				p.Constant()
			}

		case 2:
			{
				p.SetState(7206)
				p.FullColumnName()
			}

		case 3:
			{
				p.SetState(7207)
				p.FunctionCall()
			}

		case 4:
			{
				p.SetState(7208)
				p.expression(0)
			}

		case antlr.ATNInvalidAltNumber:
			goto errorExit
		}

		p.SetState(7215)
		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 (s *FunctionArgContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitFunctionArg(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *MySqlParser) FunctionArg() (localctx IFunctionArgContext) {
	localctx = NewFunctionArgContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 686, MySqlParserRULE_functionArg)
	p.SetState(7220)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1066, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7216)
			p.Constant()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(7217)
			p.FullColumnName()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(7218)
			p.FunctionCall()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(7219)
			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)
	}
}

func (s *IsExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitIsExpression(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *NotExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitNotExpression(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *LogicalExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitLogicalExpression(s)

	default:
		return t.VisitChildren(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 (s *PredicateExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitPredicateExpression(s)

	default:
		return t.VisitChildren(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(7233)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1068, p.GetParserRuleContext()) {
	case 1:
		localctx = NewNotExpressionContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx

		{
			p.SetState(7223)

			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(7224)
			p.expression(4)
		}

	case 2:
		localctx = NewIsExpressionContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(7225)
			p.predicate(0)
		}
		{
			p.SetState(7226)
			p.Match(MySqlParserIS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(7228)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == MySqlParserNOT {
			{
				p.SetState(7227)
				p.Match(MySqlParserNOT)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		}
		{
			p.SetState(7230)

			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(7232)
			p.predicate(0)
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}
	p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1))
	p.SetState(7241)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1069, 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(7235)

			if !(p.Precpred(p.GetParserRuleContext(), 3)) {
				p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 3)", ""))
				goto errorExit
			}
			{
				p.SetState(7236)
				p.LogicalOperator()
			}
			{
				p.SetState(7237)
				p.expression(4)
			}

		}
		p.SetState(7243)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1069, 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)
	}
}

func (s *SoundsLikePredicateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSoundsLikePredicate(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *ExpressionAtomPredicateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitExpressionAtomPredicate(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *SubqueryComparisonPredicateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSubqueryComparisonPredicate(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *JsonMemberOfPredicateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitJsonMemberOfPredicate(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *BinaryComparisonPredicateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitBinaryComparisonPredicate(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *InPredicateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitInPredicate(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *BetweenPredicateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitBetweenPredicate(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *IsNullPredicateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitIsNullPredicate(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *LikePredicateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitLikePredicate(s)

	default:
		return t.VisitChildren(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 (s *RegexpPredicateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitRegexpPredicate(s)

	default:
		return t.VisitChildren(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(7245)
		p.expressionAtom(0)
	}

	p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1))
	p.SetState(7311)
	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
			p.SetState(7309)
			p.GetErrorHandler().Sync(p)
			if p.HasError() {
				goto errorExit
			}

			switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1076, p.GetParserRuleContext()) {
			case 1:
				localctx = NewBinaryComparisonPredicateContext(p, NewPredicateContext(p, _parentctx, _parentState))
				localctx.(*BinaryComparisonPredicateContext).left = _prevctx

				p.PushNewRecursionContext(localctx, _startState, MySqlParserRULE_predicate)
				p.SetState(7247)

				if !(p.Precpred(p.GetParserRuleContext(), 8)) {
					p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 8)", ""))
					goto errorExit
				}
				{
					p.SetState(7248)
					p.ComparisonOperator()
				}
				{
					p.SetState(7249)

					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(7251)

				if !(p.Precpred(p.GetParserRuleContext(), 6)) {
					p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 6)", ""))
					goto errorExit
				}
				p.SetState(7253)
				p.GetErrorHandler().Sync(p)
				if p.HasError() {
					goto errorExit
				}
				_la = p.GetTokenStream().LA(1)

				if _la == MySqlParserNOT {
					{
						p.SetState(7252)
						p.Match(MySqlParserNOT)
						if p.HasError() {
							// Recognition error - abort rule
							goto errorExit
						}
					}

				}
				{
					p.SetState(7255)
					p.Match(MySqlParserBETWEEN)
					if p.HasError() {
						// Recognition error - abort rule
						goto errorExit
					}
				}
				{
					p.SetState(7256)
					p.predicate(0)
				}
				{
					p.SetState(7257)
					p.Match(MySqlParserAND)
					if p.HasError() {
						// Recognition error - abort rule
						goto errorExit
					}
				}
				{
					p.SetState(7258)
					p.predicate(7)
				}

			case 3:
				localctx = NewSoundsLikePredicateContext(p, NewPredicateContext(p, _parentctx, _parentState))
				p.PushNewRecursionContext(localctx, _startState, MySqlParserRULE_predicate)
				p.SetState(7260)

				if !(p.Precpred(p.GetParserRuleContext(), 5)) {
					p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 5)", ""))
					goto errorExit
				}
				{
					p.SetState(7261)
					p.Match(MySqlParserSOUNDS)
					if p.HasError() {
						// Recognition error - abort rule
						goto errorExit
					}
				}
				{
					p.SetState(7262)
					p.Match(MySqlParserLIKE)
					if p.HasError() {
						// Recognition error - abort rule
						goto errorExit
					}
				}
				{
					p.SetState(7263)
					p.predicate(6)
				}

			case 4:
				localctx = NewRegexpPredicateContext(p, NewPredicateContext(p, _parentctx, _parentState))
				p.PushNewRecursionContext(localctx, _startState, MySqlParserRULE_predicate)
				p.SetState(7264)

				if !(p.Precpred(p.GetParserRuleContext(), 3)) {
					p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 3)", ""))
					goto errorExit
				}
				p.SetState(7266)
				p.GetErrorHandler().Sync(p)
				if p.HasError() {
					goto errorExit
				}
				_la = p.GetTokenStream().LA(1)

				if _la == MySqlParserNOT {
					{
						p.SetState(7265)
						p.Match(MySqlParserNOT)
						if p.HasError() {
							// Recognition error - abort rule
							goto errorExit
						}
					}

				}
				{
					p.SetState(7268)

					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(7269)
					p.predicate(4)
				}

			case 5:
				localctx = NewInPredicateContext(p, NewPredicateContext(p, _parentctx, _parentState))
				p.PushNewRecursionContext(localctx, _startState, MySqlParserRULE_predicate)
				p.SetState(7270)

				if !(p.Precpred(p.GetParserRuleContext(), 10)) {
					p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 10)", ""))
					goto errorExit
				}
				p.SetState(7272)
				p.GetErrorHandler().Sync(p)
				if p.HasError() {
					goto errorExit
				}
				_la = p.GetTokenStream().LA(1)

				if _la == MySqlParserNOT {
					{
						p.SetState(7271)
						p.Match(MySqlParserNOT)
						if p.HasError() {
							// Recognition error - abort rule
							goto errorExit
						}
					}

				}
				{
					p.SetState(7274)
					p.Match(MySqlParserIN)
					if p.HasError() {
						// Recognition error - abort rule
						goto errorExit
					}
				}
				{
					p.SetState(7275)
					p.Match(MySqlParserLR_BRACKET)
					if p.HasError() {
						// Recognition error - abort rule
						goto errorExit
					}
				}
				p.SetState(7278)
				p.GetErrorHandler().Sync(p)
				if p.HasError() {
					goto errorExit
				}

				switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1073, p.GetParserRuleContext()) {
				case 1:
					{
						p.SetState(7276)
						p.SelectStatement()
					}

				case 2:
					{
						p.SetState(7277)
						p.Expressions()
					}

				case antlr.ATNInvalidAltNumber:
					goto errorExit
				}
				{
					p.SetState(7280)
					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(7282)

				if !(p.Precpred(p.GetParserRuleContext(), 9)) {
					p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 9)", ""))
					goto errorExit
				}
				{
					p.SetState(7283)
					p.Match(MySqlParserIS)
					if p.HasError() {
						// Recognition error - abort rule
						goto errorExit
					}
				}
				{
					p.SetState(7284)
					p.NullNotnull()
				}

			case 7:
				localctx = NewSubqueryComparisonPredicateContext(p, NewPredicateContext(p, _parentctx, _parentState))
				p.PushNewRecursionContext(localctx, _startState, MySqlParserRULE_predicate)
				p.SetState(7285)

				if !(p.Precpred(p.GetParserRuleContext(), 7)) {
					p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 7)", ""))
					goto errorExit
				}
				{
					p.SetState(7286)
					p.ComparisonOperator()
				}
				{
					p.SetState(7287)

					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(7288)
					p.Match(MySqlParserLR_BRACKET)
					if p.HasError() {
						// Recognition error - abort rule
						goto errorExit
					}
				}
				{
					p.SetState(7289)
					p.SelectStatement()
				}
				{
					p.SetState(7290)
					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(7292)

				if !(p.Precpred(p.GetParserRuleContext(), 4)) {
					p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 4)", ""))
					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)
					p.Match(MySqlParserLIKE)
					if p.HasError() {
						// Recognition error - abort rule
						goto errorExit
					}
				}
				{
					p.SetState(7297)
					p.predicate(0)
				}
				p.SetState(7300)
				p.GetErrorHandler().Sync(p)

				if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1075, p.GetParserRuleContext()) == 1 {
					{
						p.SetState(7298)
						p.Match(MySqlParserESCAPE)
						if p.HasError() {
							// Recognition error - abort rule
							goto errorExit
						}
					}
					{
						p.SetState(7299)
						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(7302)

				if !(p.Precpred(p.GetParserRuleContext(), 2)) {
					p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 2)", ""))
					goto errorExit
				}
				{
					p.SetState(7303)
					p.Match(MySqlParserMEMBER)
					if p.HasError() {
						// Recognition error - abort rule
						goto errorExit
					}
				}
				{
					p.SetState(7304)
					p.Match(MySqlParserOF)
					if p.HasError() {
						// Recognition error - abort rule
						goto errorExit
					}
				}
				{
					p.SetState(7305)
					p.Match(MySqlParserLR_BRACKET)
					if p.HasError() {
						// Recognition error - abort rule
						goto errorExit
					}
				}
				{
					p.SetState(7306)
					p.predicate(0)
				}
				{
					p.SetState(7307)
					p.Match(MySqlParserRR_BRACKET)
					if p.HasError() {
						// Recognition error - abort rule
						goto errorExit
					}
				}

			case antlr.ATNInvalidAltNumber:
				goto errorExit
			}

		}
		p.SetState(7313)
		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
}

// 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)
	}
}

func (s *UnaryExpressionAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitUnaryExpressionAtom(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *CollateExpressionAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCollateExpressionAtom(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *VariableAssignExpressionAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitVariableAssignExpressionAtom(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *MysqlVariableExpressionAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitMysqlVariableExpressionAtom(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *NestedExpressionAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitNestedExpressionAtom(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *NestedRowExpressionAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitNestedRowExpressionAtom(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *MathExpressionAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitMathExpressionAtom(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *ExistsExpressionAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitExistsExpressionAtom(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *IntervalExpressionAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitIntervalExpressionAtom(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *JsonExpressionAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitJsonExpressionAtom(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *SubqueryExpressionAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitSubqueryExpressionAtom(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *ConstantExpressionAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitConstantExpressionAtom(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *FunctionCallExpressionAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitFunctionCallExpressionAtom(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *BinaryExpressionAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitBinaryExpressionAtom(s)

	default:
		return t.VisitChildren(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)
	}
}

func (s *FullColumnNameExpressionAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitFullColumnNameExpressionAtom(s)

	default:
		return t.VisitChildren(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 (s *BitExpressionAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitBitExpressionAtom(s)

	default:
		return t.VisitChildren(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(7362)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1080, p.GetParserRuleContext()) {
	case 1:
		localctx = NewConstantExpressionAtomContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx

		{
			p.SetState(7315)
			p.Constant()
		}

	case 2:
		localctx = NewFullColumnNameExpressionAtomContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(7316)
			p.FullColumnName()
		}

	case 3:
		localctx = NewFunctionCallExpressionAtomContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(7317)
			p.FunctionCall()
		}

	case 4:
		localctx = NewMysqlVariableExpressionAtomContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(7318)
			p.MysqlVariable()
		}

	case 5:
		localctx = NewUnaryExpressionAtomContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(7319)
			p.UnaryOperator()
		}
		{
			p.SetState(7320)
			p.expressionAtom(12)
		}

	case 6:
		localctx = NewBinaryExpressionAtomContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(7322)
			p.Match(MySqlParserBINARY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7323)
			p.expressionAtom(11)
		}

	case 7:
		localctx = NewVariableAssignExpressionAtomContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(7324)
			p.Match(MySqlParserLOCAL_ID)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7325)
			p.Match(MySqlParserVAR_ASSIGN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7326)
			p.expressionAtom(10)
		}

	case 8:
		localctx = NewNestedExpressionAtomContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(7327)
			p.Match(MySqlParserLR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7328)
			p.expression(0)
		}
		p.SetState(7333)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		for _la == MySqlParserCOMMA {
			{
				p.SetState(7329)
				p.Match(MySqlParserCOMMA)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(7330)
				p.expression(0)
			}

			p.SetState(7335)
			p.GetErrorHandler().Sync(p)
			if p.HasError() {
				goto errorExit
			}
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(7336)
			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(7338)
			p.Match(MySqlParserROW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7339)
			p.Match(MySqlParserLR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7340)
			p.expression(0)
		}
		p.SetState(7343)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		for ok := true; ok; ok = _la == MySqlParserCOMMA {
			{
				p.SetState(7341)
				p.Match(MySqlParserCOMMA)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(7342)
				p.expression(0)
			}

			p.SetState(7345)
			p.GetErrorHandler().Sync(p)
			if p.HasError() {
				goto errorExit
			}
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(7347)
			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(7349)
			p.Match(MySqlParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7350)
			p.Match(MySqlParserLR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7351)
			p.SelectStatement()
		}
		{
			p.SetState(7352)
			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(7354)
			p.Match(MySqlParserLR_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7355)
			p.SelectStatement()
		}
		{
			p.SetState(7356)
			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(7358)
			p.Match(MySqlParserINTERVAL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7359)
			p.expression(0)
		}
		{
			p.SetState(7360)
			p.IntervalType()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}
	p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1))
	p.SetState(7385)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1082, 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(7383)
			p.GetErrorHandler().Sync(p)
			if p.HasError() {
				goto errorExit
			}

			switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1081, p.GetParserRuleContext()) {
			case 1:
				localctx = NewBitExpressionAtomContext(p, NewExpressionAtomContext(p, _parentctx, _parentState))
				localctx.(*BitExpressionAtomContext).left = _prevctx

				p.PushNewRecursionContext(localctx, _startState, MySqlParserRULE_expressionAtom)
				p.SetState(7364)

				if !(p.Precpred(p.GetParserRuleContext(), 4)) {
					p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 4)", ""))
					goto errorExit
				}
				{
					p.SetState(7365)
					p.BitOperator()
				}
				{
					p.SetState(7366)

					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(7368)

				if !(p.Precpred(p.GetParserRuleContext(), 3)) {
					p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 3)", ""))
					goto errorExit
				}
				{
					p.SetState(7369)
					p.MultOperator()
				}
				{
					p.SetState(7370)

					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(7372)

				if !(p.Precpred(p.GetParserRuleContext(), 2)) {
					p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 2)", ""))
					goto errorExit
				}
				{
					p.SetState(7373)
					p.AddOperator()
				}
				{
					p.SetState(7374)

					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(7376)

				if !(p.Precpred(p.GetParserRuleContext(), 1)) {
					p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", ""))
					goto errorExit
				}
				{
					p.SetState(7377)
					p.JsonOperator()
				}
				{
					p.SetState(7378)

					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(7380)

				if !(p.Precpred(p.GetParserRuleContext(), 14)) {
					p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 14)", ""))
					goto errorExit
				}
				{
					p.SetState(7381)
					p.Match(MySqlParserCOLLATE)
					if p.HasError() {
						// Recognition error - abort rule
						goto errorExit
					}
				}
				{
					p.SetState(7382)
					p.CollationName()
				}

			case antlr.ATNInvalidAltNumber:
				goto errorExit
			}

		}
		p.SetState(7387)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1082, 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 (s *UnaryOperatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitUnaryOperator(s)

	default:
		return t.VisitChildren(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(7388)
		_la = p.GetTokenStream().LA(1)

		if !(_la == MySqlParserNOT || ((int64((_la-1120)) & ^0x3f) == 0 && ((int64(1)<<(_la-1120))&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 (s *ComparisonOperatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitComparisonOperator(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *MySqlParser) ComparisonOperator() (localctx IComparisonOperatorContext) {
	localctx = NewComparisonOperatorContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 696, MySqlParserRULE_comparisonOperator)
	p.SetState(7404)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1083, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7390)
			p.Match(MySqlParserEQUAL_SYMBOL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(7391)
			p.Match(MySqlParserGREATER_SYMBOL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(7392)
			p.Match(MySqlParserLESS_SYMBOL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(7393)
			p.Match(MySqlParserLESS_SYMBOL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7394)
			p.Match(MySqlParserEQUAL_SYMBOL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(7395)
			p.Match(MySqlParserGREATER_SYMBOL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7396)
			p.Match(MySqlParserEQUAL_SYMBOL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(7397)
			p.Match(MySqlParserLESS_SYMBOL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7398)
			p.Match(MySqlParserGREATER_SYMBOL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(7399)
			p.Match(MySqlParserEXCLAMATION_SYMBOL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7400)
			p.Match(MySqlParserEQUAL_SYMBOL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(7401)
			p.Match(MySqlParserLESS_SYMBOL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7402)
			p.Match(MySqlParserEQUAL_SYMBOL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7403)
			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 (s *LogicalOperatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitLogicalOperator(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *MySqlParser) LogicalOperator() (localctx ILogicalOperatorContext) {
	localctx = NewLogicalOperatorContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 698, MySqlParserRULE_logicalOperator)
	p.SetState(7413)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case MySqlParserAND:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7406)
			p.Match(MySqlParserAND)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserBIT_AND_OP:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(7407)
			p.Match(MySqlParserBIT_AND_OP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7408)
			p.Match(MySqlParserBIT_AND_OP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserXOR:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(7409)
			p.Match(MySqlParserXOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserOR:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(7410)
			p.Match(MySqlParserOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserBIT_OR_OP:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(7411)
			p.Match(MySqlParserBIT_OR_OP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7412)
			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 (s *BitOperatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitBitOperator(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *MySqlParser) BitOperator() (localctx IBitOperatorContext) {
	localctx = NewBitOperatorContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 700, MySqlParserRULE_bitOperator)
	p.SetState(7422)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case MySqlParserLESS_SYMBOL:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7415)
			p.Match(MySqlParserLESS_SYMBOL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7416)
			p.Match(MySqlParserLESS_SYMBOL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserGREATER_SYMBOL:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(7417)
			p.Match(MySqlParserGREATER_SYMBOL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7418)
			p.Match(MySqlParserGREATER_SYMBOL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserBIT_AND_OP:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(7419)
			p.Match(MySqlParserBIT_AND_OP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserBIT_XOR_OP:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(7420)
			p.Match(MySqlParserBIT_XOR_OP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case MySqlParserBIT_OR_OP:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(7421)
			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 (s *MultOperatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitMultOperator(s)

	default:
		return t.VisitChildren(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(7424)
		_la = p.GetTokenStream().LA(1)

		if !((int64((_la-1117)) & ^0x3f) == 0 && ((int64(1)<<(_la-1117))&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 (s *AddOperatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitAddOperator(s)

	default:
		return t.VisitChildren(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(7426)
		_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 (s *JsonOperatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitJsonOperator(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *MySqlParser) JsonOperator() (localctx IJsonOperatorContext) {
	localctx = NewJsonOperatorContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 706, MySqlParserRULE_jsonOperator)
	p.SetState(7433)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1086, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7428)
			p.Match(MySqlParserMINUS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7429)
			p.Match(MySqlParserGREATER_SYMBOL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(7430)
			p.Match(MySqlParserMINUS)
			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
			}
		}
		{
			p.SetState(7432)
			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 (s *CharsetNameBaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitCharsetNameBase(s)

	default:
		return t.VisitChildren(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(7435)
		_la = p.GetTokenStream().LA(1)

		if !(_la == MySqlParserBINARY || ((int64((_la-746)) & ^0x3f) == 0 && ((int64(1)<<(_la-746))&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 (s *TransactionLevelBaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitTransactionLevelBase(s)

	default:
		return t.VisitChildren(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(7437)
		_la = p.GetTokenStream().LA(1)

		if !((int64((_la-799)) & ^0x3f) == 0 && ((int64(1)<<(_la-799))&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 (s *PrivilegesBaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitPrivilegesBase(s)

	default:
		return t.VisitChildren(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(7439)
		_la = p.GetTokenStream().LA(1)

		if !((int64((_la-708)) & ^0x3f) == 0 && ((int64(1)<<(_la-708))&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 (s *IntervalTypeBaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitIntervalTypeBase(s)

	default:
		return t.VisitChildren(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(7441)
		_la = p.GetTokenStream().LA(1)

		if !((int64((_la-689)) & ^0x3f) == 0 && ((int64(1)<<(_la-689))&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 (s *DataTypeBaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitDataTypeBase(s)

	default:
		return t.VisitChildren(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(7443)
		_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 (s *KeywordsCanBeIdContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitKeywordsCanBeId(s)

	default:
		return t.VisitChildren(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(7445)
		_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))&1769897061370560513) != 0) || ((int64((_la-305)) & ^0x3f) == 0 && ((int64(1)<<(_la-305))&-134217473) != 0) || ((int64((_la-369)) & ^0x3f) == 0 && ((int64(1)<<(_la-369))&-171798822913) != 0) || ((int64((_la-434)) & ^0x3f) == 0 && ((int64(1)<<(_la-434))&-33685505) != 0) || ((int64((_la-498)) & ^0x3f) == 0 && ((int64(1)<<(_la-498))&-2306265222165299201) != 0) || ((int64((_la-562)) & ^0x3f) == 0 && ((int64(1)<<(_la-562))&-35184640524289) != 0) || ((int64((_la-626)) & ^0x3f) == 0 && ((int64(1)<<(_la-626))&9222105399459575807) != 0) || ((int64((_la-697)) & ^0x3f) == 0 && ((int64(1)<<(_la-697))&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
	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
	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
	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) 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) 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) 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 (s *FunctionNameBaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case MySqlParserVisitor:
		return t.VisitFunctionNameBase(s)

	default:
		return t.VisitChildren(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(7447)
		_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))&-17179869161) != 0) || ((int64((_la-281)) & ^0x3f) == 0 && ((int64(1)<<(_la-281))&8796109397507) != 0) || _la == MySqlParserINVISIBLE || ((int64((_la-673)) & ^0x3f) == 0 && ((int64(1)<<(_la-673))&-9223372036838064127) != 0) || ((int64((_la-803)) & ^0x3f) == 0 && ((int64(1)<<(_la-803))&-8589934599) != 0) || ((int64((_la-867)) & ^0x3f) == 0 && ((int64(1)<<(_la-867))&-257) != 0) || ((int64((_la-931)) & ^0x3f) == 0 && ((int64(1)<<(_la-931))&-1) != 0) || ((int64((_la-995)) & ^0x3f) == 0 && ((int64(1)<<(_la-995))&-1057) != 0) || ((int64((_la-1059)) & ^0x3f) == 0 && ((int64(1)<<(_la-1059))&562949416550399) != 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))
	}
}
